query
stringlengths 7
9.55k
| document
stringlengths 10
363k
| metadata
dict | negatives
listlengths 0
101
| negative_scores
listlengths 0
101
| document_score
stringlengths 3
10
| document_rank
stringclasses 102
values |
|---|---|---|---|---|---|---|
Use callbacks to share common setup or constraints between actions.
|
def set_veiculo_motorista
@veiculo_motorista = VeiculoMotorista.find(params[:id])
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def setup_handler\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def workflow\n end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup\n # override and do something appropriate\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def before_action \n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def setup_signals; end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def initialize(*args)\n super\n @action = :set\nend",
"def after_set_callback; end",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def around_hooks; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def duas1(action)\n action.call\n action.call\nend",
"def shared_action(name, &block)\n @controller.shared_actions[name] = block\n end",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] |
[
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576",
"0.53124547",
"0.529654",
"0.5296262",
"0.52952296",
"0.52600986",
"0.52442724",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.5232394",
"0.523231",
"0.5227454",
"0.52226824",
"0.52201617",
"0.5212327",
"0.52079266",
"0.52050185",
"0.51754695",
"0.51726824",
"0.51710224",
"0.5166172",
"0.5159343",
"0.51578903",
"0.51522785",
"0.5152022",
"0.51518047",
"0.51456624",
"0.51398855",
"0.5133759",
"0.5112076",
"0.5111866",
"0.5111866",
"0.5110294",
"0.5106169",
"0.509231",
"0.50873137",
"0.5081088",
"0.508059",
"0.50677156",
"0.50562143",
"0.5050554",
"0.50474834",
"0.50474834",
"0.5036181",
"0.5026331",
"0.5022976",
"0.5015441",
"0.50121695",
"0.5000944",
"0.5000019",
"0.4996878",
"0.4989888",
"0.4989888",
"0.49864885",
"0.49797225",
"0.49785787",
"0.4976161",
"0.49683493",
"0.4965126",
"0.4958034",
"0.49559742",
"0.4954353",
"0.49535993",
"0.4952725",
"0.49467874",
"0.49423352",
"0.49325448",
"0.49282882",
"0.49269363",
"0.49269104",
"0.49252945",
"0.4923091",
"0.49194667",
"0.49174926",
"0.49173003",
"0.49171105",
"0.4915879",
"0.49155936"
] |
0.0
|
-1
|
Never trust parameters from the scary internet, only allow the white list through.
|
def veiculo_motorista_params
params.require(:veiculo_motorista).permit(:veiculo_id, :motorista_id, :status)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def param_whitelist\n [:role, :title]\n end",
"def expected_permitted_parameter_names; end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def allowed_params\n params.require(:user).permit(:username, :email, :password, :password_confirmation)\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def user_params \n \tparams.require(:user).permit(:name, :email, :password, :password_confirmation)# preventing CSTR\n end",
"def user_params\n params.permit(:name, :phoneNumber, :address, :postalCode, :local, :link, :counter, :latitude, :longitude) \n end",
"def valid_params_request?; end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def whitelist_url_params\n params.require(:whitelist_url).permit(:domain)\n end",
"def allowed_params\n params.require(:allowed).permit(:email)\n end",
"def permitted_params\n []\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def query_param\n\t\tparams.permit(:first_name, :last_name, :phone)\n\tend",
"def strong_params\n params.require(:success_metric).permit(param_whitelist)\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def whitelisted_user_params\n params.require(:user).\n permit( :first_name, :last_name, :email,:password,:password_confirmation,:birthday,:gender)\n end",
"def user_params\n ActionController::Parameters.permit_all_parameters = true\n params.require(:user) #.permit(:name, :surname, :phone, :password, :email, :time_zone)\n end",
"def strong_params\n params.require(:metric_change).permit(param_whitelist)\n end",
"def safe_params\n params.require(:user).permit(:name)\n end",
"def get_params\n\t\treturn ActionController::Parameters.new(self.attributes).permit(\"account_id\", \"title\", \"category\", \"introduction\", \"tags\", \"segment_type\", \"visible\", \"status\", \"main_image\")\n\tend",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def check_params; true; end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def quote_params\n params.permit!\n end",
"def valid_params?; end",
"def paramunold_params\n params.require(:paramunold).permit!\n end",
"def user_params\n\t\tparams.permit(:nickname, :avatar, :description, :password, :gender, :birthday, :email, :phone, :qq_id, :wechat_id)\n\tend",
"def filtered_parameters; end",
"def user_params\n params.permit(\n \t:id,\n \t:email, \n \t:first_name, \n \t:last_name, \n \t:password, \n \t:confirm_token, \n \t:phone_number,\n \t:facebook_link,\n \t:car_model,\n \t:license_plate)\n end",
"def filtering_params\n params.permit(:email, :name)\n end",
"def check_params\n true\n end",
"def wx_public_params\n params.require(:wx_public).permit(:nickname, :manager, :alias)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def listing_params\n\t\tparams.permit(:address, :transit_info, :rules, :other_info, :lat, :lng)\n\tend",
"def social_account_params\n\t\t\tparams.require(:social_account).permit!\n\t\tend",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def url_params\n params.require(:url).permit(:short_url, :original_url, :clicks, :ip_addresses)\n end",
"def user_params\n params.require(:user).permit(:uri, :username, :password, :realname, :email, :publicvisible)\n end",
"def model_params\n\t\tparams.require(:manager).permit(\n\t :user_name,\n :password,\n :email,\n \t\t\t)\n\tend",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def college_whitelist_params\n params.require(:college_whitelist).permit(:status)\n end",
"def active_code_params\n params[:active_code].permit\n end",
"def filtering_params\n params.permit(:email)\n end",
"def valid_params(params)\n params.permit(:user_id, :photo_id, :originX, :originY, :width, :height)\n end",
"def ip_address_params\n\t\t\tparams.require(:ip_address).permit!\n end",
"def pull_request_params\n whitelist = [\n :url,\n :id,\n :html_url,\n :diff_url,\n :patch_url,\n :issue_url,\n :number,\n :state,\n :locked,\n :title\n ]\n params.require(:pull_request).permit(whitelist)\n end",
"def reserved_params\n params.require(:reserved).permit(:name, :email, :pax, :address, :KTP, :title)\n end",
"def post_params\n if current_user.admin? \n params.permit(:title, :body, :city, :country, :gps_location, :privacy, :visible, :latitude, :longitude, images: [], files: [])\n else \n params.permit(:title, :body, :city, :country, :gps_location, :privacy,:latitude, :longitude, images: [], files: [])\n end \n end",
"def list_params\n params.permit(:name)\n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def vineyard_params\n params.permit(:vineyard_name, :email, :website_url, :phone, :address, :city, :region, :postcode, :country, :specialty, :description, :pet_friendly, :holiday, :tours, :events, :family_friendly, :cover_image, :image_one, :image_two, :image_three, :image_four, :user_id, :base64)\n end",
"def available_activity_params\n # params.require(:available_activity).permit(:type,:geometry,:properties)\n whitelisted = ActionController::Parameters.new({\n type: params.require(:available_activity)[:type],\n geometry: params.require(:available_activity)[:geometry].try(:permit!).to_h,\n properties: params.require(:available_activity)[:properties].try(:permit!).to_h\n }).try(:permit!)\n end",
"def user_params\n params.permit(:name, :username, :email, :password, :img_url, :bg_url, :coinbank)\n end",
"def user_params_pub\n\t \tparams[:user].permit(:hruid)\n\t end",
"def user_params\n params.permit(:id, :email, :password, :nickname, :status, :avatar, :flat_picture, :flatsharing_id, :member,\n :user, :color, :solde)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def url_whitelist; end",
"def admin_social_network_params\n params.require(:social_network).permit!\n end",
"def filter_params\n params.require(:filters).permit(:letters)\n end",
"def origin_params\n params.permit(:country, :state, :city, :postal_code, :address, :description)\n end",
"def valid_params(params)\n params.permit(:login, :first_name, :last_name, \n :password, :password_confirmation)\n end",
"def sensitive_params=(params)\n @sensitive_params = params\n end",
"def permit_request_params\n params.permit(:address)\n end",
"def user_params\n # Ensure a user can't give themselves admin priveleges\n params.delete(:admin) if current_user.admin?\n params.require(:user).permit(:name, :email, :admin, :image)\n end",
"def secure_params\n params.require(:location).permit(:name)\n end",
"def strong_params\n params.require( :setting ).\n permit( :global_scan_limit, :per_user_scan_limit,\n :target_whitelist_patterns, :target_blacklist_patterns )\n end",
"def question_params\n params.require(:survey_question).permit(question_whitelist)\n end",
"def case_insensitive_params\n params.require(:case_insensitive).permit(:name)\n end",
"def empire_master_no_match_params\n params.require(:empire_master_no_match).permit(:uid, :last_name, :list, :search_date, :double, :source)\n end",
"def maintenance_request_params\n params[:maintenance_request].permit! #allow all parameters for now\n end",
"def unwanted_params\n params.require(:unwanted).permit(:title, :description, :image)\n end",
"def url_params\n params[:url].permit(:full)\n end",
"def backend_user_params\n params.permit!\n end",
"def filter_params\n\t\treturn params[:candidate].permit(:name_for_filter)\n\tend",
"def speed_measurement_params\n\n #fuckit, to lazy to deal with permit crap right now\n ActionController::Parameters.permit_all_parameters = true\n\n params[:speed_measurement]\n end",
"def user_params\n params.permit(:name, :age, :username, :display_photo, :password)\n end",
"def get_params\r\n #params.require(:article).permit(:title, :permalink, :content, :source_site, :introtext, :type_id, :order_by, :searchable, :created_by, :edited_by, :published_by, :published_on, :user_id)\r\n params.require(:article).permit!\r\n\r\n end",
"def pub_params\n params.require(:pub).permit(:name, :description, :phone, :email, :hidden, :city_id, :address)\n end",
"def pass_params\n params[:pass].permit(:name, :price, :description, :colour, :events)\n end",
"def droptraining_params\n params.permit(:training_id,:user_id, :utf8, :authenticity_token, :commit)\n end",
"def person_params\n # params whitelist does *not* include admin, sub, remember_token\n # TBD: share this whitelist with the list used by configuration_permitted_parameters\n # TBD: should current_password be on this list? -- for now, leaving off, since it seems to work without\n # NOTE: do not include 'admin' in this list!\n params.require(:person).permit(\n :name, \n :email, \n :description,\n :password, \n :password_confirmation\n )\n end",
"def parameter_params\n params.require(:parameter).permit(:name, :description, :param_code, :param_value, :active_from, :active_to)\n end"
] |
[
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",
"0.62894756",
"0.6283177",
"0.6242471",
"0.62382483",
"0.6217549",
"0.6214457",
"0.6209053",
"0.6193042",
"0.6177802",
"0.6174604",
"0.61714715",
"0.6161512",
"0.6151757",
"0.6150663",
"0.61461",
"0.61213595",
"0.611406",
"0.6106206",
"0.6105114",
"0.6089039",
"0.6081015",
"0.6071004",
"0.60620916",
"0.6019971",
"0.601788",
"0.6011056",
"0.6010898",
"0.6005122",
"0.6005122",
"0.6001556",
"0.6001049",
"0.59943926",
"0.5992201",
"0.59909594",
"0.5990628",
"0.5980841",
"0.59669393",
"0.59589154",
"0.5958826",
"0.5957911",
"0.5957385",
"0.5953072",
"0.59526145",
"0.5943361",
"0.59386164",
"0.59375334",
"0.59375334",
"0.5933856",
"0.59292704",
"0.59254247",
"0.5924164",
"0.59167904",
"0.59088355",
"0.5907542",
"0.59064597",
"0.5906243",
"0.5898226",
"0.589687",
"0.5896091",
"0.5894501",
"0.5894289",
"0.5891739",
"0.58860534",
"0.5882406",
"0.587974",
"0.58738774",
"0.5869024",
"0.58679986",
"0.5867561",
"0.5865932",
"0.5864461",
"0.58639693",
"0.58617616",
"0.5861436",
"0.5860451",
"0.58602303",
"0.5854586",
"0.58537364",
"0.5850427",
"0.5850199"
] |
0.0
|
-1
|
Add support for getting comments
|
def getComments
self.root_comments
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def comments; end",
"def comments; end",
"def comments; end",
"def comments; end",
"def comments; end",
"def comments; end",
"def consume_comments; end",
"def comments\n pull_comments\n @comments_list\n end",
"def comments\n\t\t\t@comments ||= read_comments\n\t\tend",
"def comments\n client.get(\"/#{id}/comments\")\n end",
"def comments\n @list.client.get(\"#{url}/comments\")\n end",
"def comments\n @list.client.get(\"#{url}/comments\")\n end",
"def comments; rest_query(:comment); end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comment; end",
"def comments\n expose Challenge.comments(@oauth_token, params[:challenge_id].strip)\n end",
"def comments=(_arg0); end",
"def comments=(_arg0); end",
"def comments=(_arg0); end",
"def comments=(_arg0); end",
"def comments=(_arg0); end",
"def comment comment\n end",
"def comment?; end",
"def comment?; end",
"def get_comments()\n return self.get_all_comments()\n #issues = @issues\n #issues.each do |issue|\n # puts \"Processing issue #{issue['number']}...\"\n # comments = client.issue_comments( REPO, issue.number ) \n # num = issue['number']\n # @comments[num] = comments\n # issue[\"comments\"] = comments\n #end\n #return @comments\n end",
"def comments\n @docstring.all\n end",
"def customer_comments\n end",
"def default_allows_comments?; true; end",
"def comments\n get_ticket_property_list(\"comments\" , Unfuddled::Comment)\n end",
"def comments(options={})\n self.class.parse_comments(request(singular(user_id) + \"/comments\", options))\n end",
"def processing_comments(opts = {})\n find_collection(\"processingComments\", opts)\n end",
"def comments(options={})\n parse_comments(request(singular(id) + \"comments\", options))\n end",
"def comments\n @comments\n end",
"def comments(options = {})\n comments_resource(options)\n end",
"def getComments\r\n\t\t\t\t\treturn @comments\r\n\t\t\t\tend",
"def comments(options={})\n @comments ||= self.class.parse_comments(request(singular(question_id) + \"/comments\", options))\n end",
"def comments\n @comments\n end",
"def return_comment\n @comments\n end",
"def comments(*options)\n options.insert 0, project_id\n options.insert 1, id\n easy_finder(provider_parent(self.class)::Comment, :all, options, 2)\n end",
"def comments\n @comments\n end",
"def comments\n @comments\n end",
"def add_comment(comment); end",
"def comments(post_id)\n records \"comment\", \"/msg/comments/#{post_id}\"\n end",
"def create_comments\n end",
"def create_comments\n end",
"def create_comments\n end",
"def pull_comments\n GithubApi.pull_comments(self)\n end",
"def comment(options)\n get(\"/content/items/#{options.delete(:item)}/comments/#{options[:id]}\",options)\n end",
"def supports_comments?\n false\n end",
"def supports_comments?\n false\n end",
"def comments\n @data['comments']\n end",
"def comments\n @data['comments']\n end",
"def comments\n @data['comments']\n end",
"def comments\n Birdman::ApiPaginatedCollection.new(\"movies/#{id}/comments\")\n end",
"def comments\n if has_comments?\n @repository.load(:comments, number).map do |item|\n Github::Issue::Comment.new(item)\n end\n else \n []\n end\n end",
"def comments(options={})\n parse_comments(request(singular(answer_id) + \"/comments\", options))\n end",
"def list_comments\n hc = if has_comments_valided?\n comments(valided: true).collect do |dcom|\n next unless dcom[:ok]\n (\n (dcom[:ps] + ', le ' + dcom[:at].as_human_date).in_div(class: 'c_info') +\n traite_comments(dcom[:c]).in_div(class: 'c_content') + \"\".in_div(class: 'clear')\n ).in_div(class: 'comment')\n end.join('')\n else\n \"Aucun commentaire sur cet article pour le moment.\".in_div(class: 'italic small')\n end\n hc.prepend('<a name=\"lire_comments\"></a>')\n return hc\n end",
"def comments(options = {})\n options = { query: options } if options.any?\n @party.get(\"forms/#{@id}/comments\", options)['Comments']\n end",
"def comments()\n return MicrosoftGraph::Drives::Item::Items::Item::Workbook::Comments::CommentsRequestBuilder.new(@path_parameters, @request_adapter)\n end",
"def pull_comments\n @scrape.extract_comments.each do |comment_text|\n comment = Comment.new(comment_text)\n add_comment(comment)\n end\n end",
"def pull_request_comments(repo, number, options = {})\n # return the comments for a pull request\n paginate(\"#{Repository.path repo}/pulls/#{number}/comments\", options)\n end",
"def lookup_comment\n lookup_general(Comment)\n end",
"def _get_comments_from_gh()\n comments = []\n page = 1\n done = false\n until done\n puts \"Comment Page #{page}\"\n newcomments = self.client.issues_comments( REPO, { :page => page} )\n comments += newcomments\n done = newcomments == []\n page = page + 1\n end\n return comments\n end",
"def uses_legacy_comments?\n end",
"def comment\n @comment\n end",
"def comments_for(url)\n get_data(\"comments/show/#{FORMAT}?url=#{url}\")\n end",
"def comments(options = {})\n @comments_list ||= CommentList.new(@id)\n return @comments_list.top_level(options)\n end",
"def comments(options = {})\n urn = options.delete(:urn)\n path = \"/socialActions/#{urn}/comments\"\n get(path, options)\n end",
"def getComments(list)\r\n comments = \"\"\r\n dbg(\"Kommentarer:\")\r\n list.each { |s| \r\n dbg(\"Kommentar:\")\r\n dbg(s)\r\n dbg(s[\"comment\"])\r\n \tcomments = comments + \"<p>\" + s[\"author_name\"] + \":\" + s[\"comment\"] + \"</p>\"\r\n \tdbg(s[\"comment\"])\r\n }\r\n return comments\r\nend",
"def getComments(list)\r\n comments = \"\"\r\n dbg(\"Kommentarer:\")\r\n list.each { |s| \r\n dbg(\"Kommentar:\")\r\n dbg(s)\r\n dbg(s[\"comment\"])\r\n \tcomments = comments + \"<p>\" + s[\"author_name\"] + \":\" + s[\"comment\"] + \"</p>\"\r\n \tdbg(s[\"comment\"])\r\n }\r\n return comments\r\nend",
"def parse_comments(comments); end",
"def consume_comments\n c = comments\n discard_comments\n c\n end",
"def comments\n if @comment_feed.comments.nil?\n @comment_feed.fetch\n end\n\n @comment_feed.comments\n end",
"def line_comments_option; end",
"def GetComments id,params = {}\n\n params = params.merge(path: \"tickets/#{id}/comments.json\")\n APICall(params)\n\n end",
"def get_comment\n\t\treturn @comment\n\tend",
"def comments\n Comment.where(:article => @id)\n end",
"def get_comments(parameters = {})\n if @answer_comments_url\n hash,url =request(@answer_comments_url, parameters)\n Comments.new hash, url\n else\n nil\n end\n end",
"def visit_Comment(comment, *rest)\n end",
"def get_comments(channel_name)\n uri = create_api_uri(@@base_uri, channel_name, 'getComments')\n return get(uri)\n end",
"def list_tasks_with_comments\n all_tasks = Task.all\n all_tasks.each do |task|\n puts \"Task: \" + task.title\n task.comments.each {|c| puts \"Comment: \" + c.comment}\n end\nend",
"def links\n {\n comments: \"/api/v1/tasks/#{id}/comments\",\n }\n end",
"def comments_range; end",
"def comments_range; end"
] |
[
"0.81732225",
"0.81732225",
"0.81732225",
"0.81732225",
"0.81732225",
"0.81732225",
"0.77419966",
"0.75509065",
"0.7477337",
"0.73922426",
"0.7225233",
"0.7225233",
"0.7214852",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7174112",
"0.7119219",
"0.7067203",
"0.7067203",
"0.7067203",
"0.7067203",
"0.7067203",
"0.70664096",
"0.7040214",
"0.7040214",
"0.7023394",
"0.70160884",
"0.70098627",
"0.7002396",
"0.69802487",
"0.6975276",
"0.6925841",
"0.6919423",
"0.6904019",
"0.6894965",
"0.6859837",
"0.6833555",
"0.68333876",
"0.68164814",
"0.6800149",
"0.67921674",
"0.67921674",
"0.678719",
"0.67752874",
"0.67719537",
"0.67719537",
"0.67719537",
"0.67612404",
"0.675905",
"0.67182344",
"0.67182344",
"0.6709565",
"0.6709565",
"0.6709565",
"0.6708228",
"0.6683815",
"0.66817886",
"0.6659084",
"0.66575176",
"0.6654738",
"0.66287035",
"0.65961677",
"0.65796864",
"0.65562946",
"0.6553749",
"0.65348214",
"0.6504569",
"0.64791334",
"0.6474339",
"0.6470548",
"0.6470548",
"0.6461785",
"0.6452194",
"0.6451491",
"0.64446324",
"0.6428417",
"0.6426909",
"0.6405344",
"0.638385",
"0.63805515",
"0.6378294",
"0.6358801",
"0.6356071",
"0.6348508",
"0.6348508"
] |
0.66210926
|
76
|
Overwriting the sign_out redirect path method
|
def after_sign_out_path_for(resource_or_scope)
if resource_or_scope == :admin
new_admin_session_path
else
new_user_session_path
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def after_sign_out_path_for(resource_or_scope)\n '/signed_out'\n end",
"def after_sign_out_path_for(_resource_or_scope)\n '/'\n end",
"def after_sign_out_path_for(resource_or_scope); end",
"def signout_url\n {:controller => 'auth', :action => 'signout'}\n end",
"def after_sign_out_path_for(resource_or_scope)\n '/users/sign_in'\n end",
"def after_sign_out_path_for(resource_or_scope)\n \"/app/users/sign_in\"\n end",
"def after_sign_out_path_for(resource_or_scope)\n Faraday.get(logout_path) if logout_path.present?\n super(resource_or_scope)\n end",
"def after_sign_out_path_for(resource)\n '/'\n end",
"def after_sign_out_path_for(user)\n '/'\n end",
"def after_sign_out_path_for(_resource_or_scope)\n user_session_path\n end",
"def after_sign_out_path_for(_resource_or_scope)\n user_session_path\n end",
"def after_sign_out_path_for(_resource_or_scope)\n user_session_path\n end",
"def after_sign_out_path_for(_resource_or_scope)\n user_session_path\n end",
"def sign_out_and_redirect(resource_or_scope); end",
"def after_sign_out_path_for(resource_or_scope)\n # caught by apache to trigger pubcookie logout\n '/logout'\n end",
"def after_sign_out_path_for(resource_or_scope)\n flash[:logout] = true\n root_path\n end",
"def sign_out_and_redirect!(return_to = \"/\")\n sign_out_user\n redirect_to sign_out_url(return_to)\n end",
"def after_sign_out_path_for(resource)\n \tnew_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n user_session_path\n end",
"def after_sign_out_path_for(resource)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n '/'\n end",
"def after_sign_out_path_for(resource_or_scope)\n '/'\n end",
"def after_sign_out_path_for user\n reset_session\n\n # for hijacking\n # cookies.delete :secure_user_id\n\n new_user_session_path\n # root_path\n end",
"def after_sign_out_path_for(_resource_or_scope)\n # require 'pry'\n # binding.pry\n # Note: at this time: flash[:notice] => \"Signed out successfully.\"\n # current_user is nil.\n new_user_session_path # signIn page\n end",
"def after_sign_out_path_for(resource_or_scope)\n # path before sign out request\n \"#{URI(request.referer).path}?logged_out=1\"\n end",
"def destroy\n super\n after_sign_out_path_for(resource)\n end",
"def sign_out\n\n # mark them as signed out.\n # (this is a helper method of devise, the rails ruby gem we're using for\n # authentication in the sample app.)\n # \n # \n #session_sign_out <---- NEED TO CHANGE TO CUSTOM USER SIGN OUT\n\n # send them back to the homepage.\n redirect_to root_path\n\n end",
"def after_sign_out_path_for(resource_or_scope)\n if request.params[:type] == \"sso\"\n Rails.configuration.devise[:sign_out_redirect_url]\n else\n super\n end\n end",
"def after_sign_out_path_for(resource_or_scope)\r\n '/'\r\n end",
"def after_sign_out_path_for(resource_or_scope)\n sign_in_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n sign_in_path\n end",
"def after_sign_out_path_for(_resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(_resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(_resource)\n root_path\n end",
"def after_sign_out_path_for(_resource)\n root_path\n end",
"def after_sign_out_path_for(_resource_or_scope)\n root_path\n # new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n cookies.delete :pa_auth_token\n \n \"#{Civiccommons::PeopleAggregator.URL}/logout.php?redirect=http://#{request.host}#{request.port == \"80\" ? nil : \":#{request.port}\"}\"\n end",
"def after_sign_out_path_for(resource)\n #if current_user_signed_in?\n # redirect_to home_path \n # else\n redirect_to site_index_path \n #end \n end",
"def after_sign_out_path_for(_resource)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource)\n\t\tnew_user_session_path\n\tend",
"def after_sign_out_path_for(resource_or_scope)\n user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path \n end",
"def sign_out\n logout\n end",
"def after_sign_out_path_for(resource_or_scope)\n if logout_path.present?\n logout_path\n else\n super(resource_or_scope)\n end\n end",
"def after_sign_out_path_for(resource_or_scope)\n if logout_path.present?\n logout_path\n else\n super(resource_or_scope)\n end\n end",
"def after_sign_out_path_for(resource_or_scope)\n if logout_path.present?\n logout_path\n else\n super(resource_or_scope)\n end\n end",
"def after_sign_out_path_for(resource_or_scope)\n if logout_path.present?\n logout_path\n else\n super(resource_or_scope)\n end\n end",
"def after_sign_out_path_for(resource_or_scope)\n \tuser_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n \tlogin_path\n \tend",
"def after_sign_out_path_for(resource_or_scope)\n login_url\n end",
"def after_sign_out_path_for(resource_or_scope)\n home_path(:ref => \"logout\")\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n \tlogin_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n \t\t\troot_path\n \t\t end",
"def after_sign_out_path_for(_resource)\n root_url\n end",
"def after_sign_out_path_for resource_or_scope\n redirect_uri = params[:redirect_uri]\n redirect_uri ? redirect_uri : super\n end",
"def after_sign_out_path_for(resource_or_scope)\n '/members/sign_in'\n end",
"def signout\n self.oaw_signout\n redirect_to root_url\n end",
"def after_sign_out_path_for(resource)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n login_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n # root_path\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\r\n login_path\r\n end",
"def after_sign_out_path_for(_)\n root_url\n end",
"def after_sign_out_path_for(resource)\r\n app_root + \"/sessions/new\"\r\n end",
"def after_sign_out_path_for(resource)\n root_path\n end",
"def after_sign_out_path_for(resource)\n root_path\n end",
"def after_sign_out_path_for(resource)\n root_path\n end",
"def signed_out_user\n redirect_to root_path unless !user_signed_in?\n end",
"def after_sign_out_path_for(params)\n bienvenida_path\n end",
"def destroy\n redirect_path = after_sign_out_path_for(\"user\")\n signed_out = (Devise.sign_out_all_scopes ? sign_out : sign_out(\"user\"))\n set_flash_message :notice, :signed_out if signed_out && is_navigational_format?\n super\n end",
"def after_sign_out_path_for(_resource)\n I18n.locale == I18n.default_locale ? '/' : \"/#{I18n.locale}\"\n end",
"def after_sign_out_path_for(_resource_or_scope)\n home_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n \tnew_user_session_path\n end",
"def after_sign_out_path_for(user)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource)\n home_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end",
"def after_sign_out_path_for(resource_or_scope)\n new_user_session_path\n end"
] |
[
"0.8102037",
"0.8007481",
"0.7984188",
"0.79324496",
"0.7897868",
"0.78892565",
"0.7874593",
"0.78685254",
"0.7857867",
"0.78436327",
"0.78436327",
"0.78436327",
"0.78436327",
"0.7842701",
"0.7821579",
"0.77880424",
"0.7748489",
"0.77373666",
"0.7731692",
"0.77291566",
"0.77291566",
"0.77291566",
"0.77291566",
"0.77291566",
"0.77275157",
"0.77275157",
"0.77213097",
"0.7716111",
"0.77091455",
"0.7708274",
"0.7705286",
"0.7694537",
"0.769133",
"0.76831216",
"0.76831216",
"0.7682263",
"0.7682263",
"0.76777554",
"0.76777554",
"0.766948",
"0.76651865",
"0.7643722",
"0.7641334",
"0.7640336",
"0.7632876",
"0.76290107",
"0.7623703",
"0.7622437",
"0.7622437",
"0.7622437",
"0.7622437",
"0.7620571",
"0.76168233",
"0.76150995",
"0.7613417",
"0.76068157",
"0.7601874",
"0.75970936",
"0.75918543",
"0.7589092",
"0.7588269",
"0.75851965",
"0.7572588",
"0.75579655",
"0.75575614",
"0.7550016",
"0.75415194",
"0.75405365",
"0.7534009",
"0.7534009",
"0.7534009",
"0.7527172",
"0.7521995",
"0.75215167",
"0.75173414",
"0.7514277",
"0.7509254",
"0.7504709",
"0.74846214",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154",
"0.74819154"
] |
0.0
|
-1
|
need to refactor this, but home_controller cannot do multiple skips??
|
def validate_user_authorization
user = User.find_by_id(params[:id])
require_valid_user user
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def skips; end",
"def skipped; end",
"def skip\n end",
"def skip\n end",
"def skipped!; end",
"def skip_actions; end",
"def index\n redirect_to disabled_path\n # unless logged_in?\n # redirect_to tour_path\n # else\n # @current_item = \"my_hsa\"\n # end\n end",
"def skip\n @page_handler.skip\n end",
"def skipped?; end",
"def skipped?; end",
"def skipped?; end",
"def skipped?; end",
"def skips_post \n @skips_post\n end",
"def index\n if !/(scrape)/.match(request.url).nil?\n # obviously temporary \n commence_scraping\n elsif !/(releases.json)/.match(request.url).nil?\n get_releases\n elsif !/(videos.json)/.match(request.url).nil?\n get_youtube\n elsif !/(merch.json)/.match(request.url).nil?\n get_merch\n elsif !/(youtube_api_fetch)/.match(request.url).nil?\n youtube_api_fetch\n end\n end",
"def skip_during; end",
"def skip_during; end",
"def index\n if logged_in?\n redirect_to :controller => 'account', :action => 'mypage'\n else\n if User.count > 0\n redirect_to :controller => 'account', :action => 'signup'\n else\n redirect_to :controller => 'recommend', :action => 'question'\n end\n end\n end",
"def skip\n\t\tif @skipped==false \n\t\t\tswitch_player()\n\t\t\t@skipped = true \n\t\telsif @skipped==true \n\t\t\tend_game()\n\t\tend \n\tend",
"def skip_page!\n raise(SkipPage)\n end",
"def skip\n @skip = true\n end",
"def nav_check\n @skip_nav = true\n end",
"def test_home_page_redirects\n \n post('admin_home', {}, {})\n assert_redirected_to(:controller => 'tracker', :action => 'index')\n \n post('reviewer_home', {}, {})\n assert_redirected_to(:controller => 'tracker', :action => 'index')\n \n post('manager_home', {}, {})\n assert_redirected_to(:controller => 'tracker', :action => 'index')\n \n post('pcb_admin_home', {}, {})\n assert_redirected_to(:controller => 'tracker', :action => 'index')\n \n post('designer_home', {}, {})\n assert_redirected_to(:controller => 'tracker', :action => 'index')\n \n end",
"def skip!\n @skip ||= true\n end",
"def record_not_found\n redirect_to four_oh_four_url\n end",
"def skip_after; end",
"def homepage\n if params[\"search\"] #if they push the customer search button\n if params[\"search_field\"] != \"\"\n customer = params[\"search_field\"].gsub(\" \", \"_\")\n else\n customer = \"add_new_customer\"\n end\n redirect_to \"/search/#{customer}\" and return\n elsif params[\"florists_access\"]\n redirect_to \"/florists\" and return\n elsif params[\"plans_access\"]\n redirect_to \"/plans\" and return\n elsif params[\"demo_products_access\"]\n redirect_to \"/demo_products\" and return\n elsif params[\"update_view\"]\n emp_update = Employee.where(id: session[\"found_user_id\"]).first\n emp_update.view_pref = params[\"view\"]\n emp_update.save!\n redirect_to home_path and return\n elsif params[\"clear\"]\n redirect_to home_path and return\n elsif params[\"date_range\"]\n if params[\"beg_date\"] == \"\"\n redirect_to home_path and return\n else\n @view_prefs = [\"all\"] + Employee.where(florist_id: session[\"found_florist_id\"]).where(status: \"Active\").uniq.pluck(:username)\n @date = params[\"beg_date\"]\n redirect_to \"/home/#{@date}\" and return\n end\n end\n end",
"def skip_step\n session[:skipped_steps] ||= []\n session[:skipped_steps].push current_step\n\n return redirect_to workflow_url\n end",
"def view_handler\n index = params[:index].to_i\n url = params[:url]\n msg = params[:msg]\n if index == 0 #backword\n session[:page_step] -= 1 #step_back\n url = session[('page' + session[:page_step].to_s).to_sym] \n else #forward\n session[:page_step] += 1 \n session[('page' + session[:page_step].to_s).to_sym] = url\n end\n\n #redirect to the page by url \n if msg.nil? \n redirect_to url\n else\n redirect_to url, :notice => msg\n end \n end",
"def home\n if Employee.where(id: session[\"found_user_id\"]).first.status == \"Inactive\" || Florist.where(id: session[\"found_florist_id\"]).first.status == \"Inactive\"\n redirect_to \"/login\" and return\n else # do nothing\n end \n if Employee.where(id: session[\"found_user_id\"]).first.view_pref == \"all\" ||\n Employee.where(florist_id: session[\"found_florist_id\"]).where(username: Employee.where(id: session[\"found_user_id\"]).first.view_pref).first == nil\n @events = Event.where(florist_id: session[\"found_florist_id\"]).where(\"event_status not like 'Lost'\").where(\"event_status not like 'Completed'\").order(\"date_of_event\").paginate(:page => params[:page], :per_page => 25)\n else\n view_pref = Employee.where(id: session[\"found_user_id\"]).first.view_pref\n employee_id = Employee.where(florist_id: session[\"found_florist_id\"]).where(username: view_pref).first.id\n @events = Event.where(florist_id: session[\"found_florist_id\"]).where(employee_id: employee_id).where(\"event_status not like 'Lost'\").where(\"event_status not like 'Completed'\").order(\"date_of_event\").paginate(:page => params[:page], :per_page => 25)\n end\n @view_prefs = [\"all\"] + Employee.where(florist_id: session[\"found_florist_id\"]).where(status: \"Active\").uniq.pluck(:username)\n render(:homepage) and return\n end",
"def controller_actions_should_fail_if_not_logged_in(cont, opts={})\n except= opts[:except] || []\n actions_to_test= get_all_actions(cont).reject{ |a| except.include?(a) }\n actions_to_test += opts[:include] if opts[:include]\n actions_to_test.each do |a|\n get a\n response.should_not be_success\n response.should redirect_to('http://test.host/')\n end\n end",
"def skips=(_arg0); end",
"def redirect_if_disabled\n if !Seek::Config.models_enabled\n redirect_to :controller => 'home'\n end\n end",
"def root\r\n if can? :read, :landing\r\n redirect_to(:controller => 'landing', :action => 'index') and return\r\n end\r\n [Enrollment, Professor, ScholarshipDuration, Phase, Course, City, User, Student].each do |model|\r\n if can? :read, model\r\n redirect_to(:controller => model.name.underscore.pluralize.downcase, :action => 'index') and return\r\n end\r\n end\r\n end",
"def index\n redirect_to(:action => 'login') unless logged_in? \n end",
"def test_home\n @current_test_name = \"Arch - Testing Home Page\"\n each_driver do\n each_view_redirects do\n common_elements?\n end\n end\n end",
"def skips_pre \n @skips_pre\n end",
"def home\n # do nothing\n end",
"def skip?\n false \n end",
"def index\n # The hook below can access controller's instance variables.\n if current_user\n if current_user.role?:livia_admin\n redirect_to companies_url\n elsif is_secretary_or_team_manager?\n redirect_to \"/wfm/notes\"\n elsif current_user.end_user\n redirect_to physical_clientservices_home_index_path\n elsif is_client\n redirect_to matter_clients_url\n elsif current_user.role?:lawfirm_admin\n redirect_to lawfirm_admins_url\n return\n end\n else\n flash[:error] = t(:flash_DB_error)\n redirect_to login_url\n end\n end",
"def index\n redirect_to(:action => 'login') #unless logged_in? || User.count > 0\n end",
"def index\n session[:previous_url] = request.referer\n @houses = House.all\n @role = session[:role]\n if @role == \"househunter\"\n @househunter = Househunter.find_by(:users_id => session[:user_id])\n elsif @role == \"realtor\"\n @realtor = Realtor.find_by(:users_id => session[:user_id])\n end\n end",
"def index_wip\n @assets = Asset.find(:all, :conditions => { {:name => :State, :op => \"IN\"} => [\"Skip\", \"Fail\"] })\n render :action => :index, :back => '/app'\n end",
"def home\n error_404 unless (@page = Page.where(:link_url => '/').first).present?\n \n call_back\n \n @test = @profile\n @test2 = @current_patner.nil?\n \n # Member.project; Project.hoster\n \n if !Project.all.empty?\n @projects = Project.all\n end\n end",
"def index\n if request.query_string.present? \n render :view => 'start/finish' and return\n end\n redirect_to login_path if current_user.nil?\n end",
"def index\n if session[:user_id] != nil \n redirect_to '/home'\n end\n end",
"def index\n if session[:user_id] != nil \n redirect_to '/home'\n end\n end",
"def skips_post\n @@skips_post = true\n end",
"def reviewer_home\n redirect_to(:action => 'index')\n end",
"def home\n \tnickname = current_usuario.nickname\n \t@usuario = Usuario.find_by_nickname(nickname)\n \t\tif @usuario\n\t\t \tputs @usuario.class\n\t\t \t#@posts = @usuario.posts.all.order(created_at: :desc).paginate(page: params[:page], per_page: 6)\n @misArticulos = Articulo.where(\"usuario_id = ?\", \"#{@usuario.id}\").order(created_at: :desc)\n\t\t \trender :home\n\t\telse\n\t\t\trender file: 'public/404', status: 404, formats: [:html]\n\t\tend\n end",
"def incomplete\n redirect_to ladders_url\n end",
"def home\n error_404 unless (@page = Page.where(:link_url => '/').first).present?\n @banners = Banner.order('position ASC')\n #@banners = defined?(Banner).blank? ? [] : Banner.all\n end",
"def index\n redirect_to not_found_path\n end",
"def resource_skipped(resource, action, conditional)\n end",
"def setup_index_view()\n # Perhaps I'm not doing something right...\n # I don't have a single line of duplicated code\n # in those in my get and post calls, so this is \n # difficult to refactor.\nend",
"def provide_navigation_by_all_skippers\n # Interface method\n end",
"def index\n redirect_to :back\n rescue ActionController::RedirectBackError\n redirect_to root_path\n end",
"def show\n redirect_to root_url unless @page\n end",
"def go_home\n return unless can_go_home? && wants_to_go_home?\n pack_bags\n get_tickets\n board_plane\nend",
"def index\n @pagina_principals = PaginaPrincipal.all\n def index\n if( !(session[:cafe] != nil && session[:cafe] != '') )\n redirect_to '/'\n end\n end\n end",
"def manager_home_setup\n\n @sort_order = {:priority => 'DESC'}\n @sort_order.default = 'ASC'\n flash[:sort_order] = @sort_order\n \n design_reviews = get_active_reviews\n\n # TODO: These sorts are expensive. Make this faster.\n @active_reviews = design_reviews[:active].sort_by { |dr| [dr[:review].age] }.reverse\n @inactive_reviews = design_reviews[:inactive].sort_by { |dr| [dr[:review].priority.value, dr[:review].age] }\n\n @submissions = BoardDesignEntry.submission_count\n session[:return_to] = {:controller => 'tracker', :action => 'index'}\n\n end",
"def skipped!\n @skipped = true\n end",
"def last_visited(action_name, controller_name)\n if(action_name =='find' and controller_name == 'search')\n session[:action]='back'\n session[:controller]=controller_name\n elsif(action_name =='index' and controller_name == 'main_menu')\n session[:action]=action_name\n session[:controller]=controller_name\n end\n end",
"def home_page\n nil\n end",
"def list\n redirect_to controller: :content_pages, action: :view if current_user.nil?\n redirect_to controller: :student_task, action: :list if current_user.try(:student?)\n end",
"def home\n redirect_path = Redirect.find_by_uri request\n if redirect_path\n redirect_to redirect_path\n else\n @hotels = Hotel.limit(10)\n @comments = Comment.latest.limit(5)\n end\n end",
"def skip\n redirect_to claim_url(current_policy_routing_name, \"name\")\n end",
"def index\n @menu='photos' #Set the menu variable\n $title=t(:title_photos) #Set the title variable\n if !check_session #Validate if the user session is active\n return #If not force return to trigger the redirect of the check_session function\n end\n @page_aux = params[:page] #Retrieve the params from the query string\n @page = @page_aux =~ /\\A\\d+\\z/ ? @page_aux.to_i : 0 #Validate if the page_aux param can be parsed as an integer, otherwise set it to cero\n response = Photo.all(session[:user],@page) #Retrieve all the photos from the model\n if response[0] #Validate if the response was successfull\n @photos_list = response[1] #Get the photos list from the response\n @total_pages = response[3].to_i #Get the total numer of pages from the response\n @previous_page = @page > 0 ? @page-1 : -1 #Calculate the previous page number, if we are at the first page, then it will set to minus one\n @next_page = @page+1 < @total_pages ? @page+1 : -1 #Calculate the next page number, if we are at the last page, then it will set to minus one\n elsif validate_authorized_access(response[1]) #If the response was unsucessful, validate if it was caused by unauthorized access to the app or expired session\n flash[:danger] = t(:photo_list_error_flash) #Set the error message to the user\n redirect_to error_general_error_path #Redirect the user to the generic error page\n else \n return #If not force return to trigger the redirect of the check_session function\n end\n rescue #Error Handilng code\n general_error_redirection('Controller: '+params[:controller]+'.'+action_name,$!)\n end",
"def home\n @teacher = current_teacher\n @school = School.find( current_teacher.school_id)\n @first_login = params[:first_login] != nil\n @first_home = params[:first_home] != nil\n @view_all = params[:view_all] != nil\n @my_students = Student.where(id: Session.where(session_teacher: @teacher.id).group('session_student').order('count(*)').select('session_student').limit(8))\n @all_students = Student.where(school_id: current_teacher.school_id).order( 'full_name ASC')\n end",
"def index\n # Handle bookmarked or otherwise incorrect GETs to the login action\n if request.method == :get\n redirect_to login_path\n else\n redirect_to member_home_path\n end\n end",
"def continue_game\n redirect_to scores_url unless show_score?\n end",
"def test_on_back_requests\n controller = new_controller\n go_back controller, '/path1'\n assert_equal nil, controller.session['previous_paths']\n end",
"def index\n redirect_to(:action => 'signup') unless logged_in? or User.count > 0\n end",
"def index\n redirect_to(:action => 'signup') unless logged_in? or User.count > 0\n end",
"def index\n # Insert ruby code...\n redirect_to home_path if current_user\n end",
"def cannot_edit_All\n if @page.name == Rails.application.config.ALL_PAGE\n redirect_to show_all_path\n end\n end",
"def check_next_and_prev\n if params[:prev] == \"true\"\n if session[:from] - 12 >= 0\n session[:from] -= 12\n session[:to] -= 12\n end\n redirect_to recipes_path\n end\n\n if params[:next] == \"true\"\n if session[:to] + 12 <= session[:search_count]\n session[:to] += 12\n session[:from] += 12\n end\n redirect_to recipes_path\n end\n end",
"def handle_backtrack\n\t\tend",
"def home\r\n \r\n end",
"def index\n session[:arr_instr_info] = []\n session[:submiss_title] = ''\n redirect_to(:action => 'signup') unless logged_in? || User.count > 0\n end",
"def index\n # I want all usrs except Guest:\n @usrs = Usr.where(\"id > 1\").order(:name).page params[:page]\n end",
"def paginate; false; end",
"def index\n @courses = Course.all[0..5]\n\n @steps = {\n \"Choose courses\" => \"search\",\n \"Create groups\" => \"users\",\n \"Watch videos\" => \"play-circle\",\n \"Build products\" => \"rocket\",\n \"Get help\" => \"question\",\n \"Do exercises\" => \"pencil\"\n }\n\n @skip_header = true\n end",
"def index\n redirect_back_or_default \"/\"\n end",
"def index\n redirect_to(:action => 'signup') unless logged_in? || User.count > 0\n end",
"def index\n redirect_to(:action => 'signup') unless logged_in? || User.count > 0\n end",
"def index\n redirect_to(:action => 'signup') unless logged_in? || User.count > 0\n end",
"def show\n\n @skip_footer_for_home = true\n\n end",
"def continue; end",
"def continue; end",
"def home\n \n \n \n # @landing=Refinery::Redirects::Redirect.find(1)\n #require 'uri'\n \n #url=@landing.Mainpage_url\n \n \n @headline = Refinery::Headlines::Headline.find(2)\n @side_headline=Refinery::SideHeadlines::SideHeadline.order('position ASC')\n @editors_pick=Refinery::EditorsPicks::EditorsPick.order('position DESC')\n @editors_pick_1=@editors_pick[0]\n @editors_pick_2=@editors_pick[1]\n @editors_pick_3=@editors_pick[2]\n @editors_pick_4=@editors_pick[3]\n \n @south=Refinery::SouthernMinutes::SouthernMinute.order('position DESC')\n @south_1=@south[0]\n @south_2=@south[1]\n @south_3=@south[2]\n @south_4=@south[3]\n @elephants=Refinery::Elephants::Elephant.order('position DESC')\n @elephant=@elephants.first\n @ears=Refinery::Ears::Ear.order('position DESC')\n @ear=@ears.first\n \n @latest=Refinery::Latests::Latest.order('position DESC')\n @politics=Refinery::Politics::Politic.order('position DESC')\n @news=Refinery::NewsSections::NewsSection.order('position DESC')\n @blog=Refinery::Blogs::Blog.order('position DESC')\n @sports=Refinery::Socials::Social.order('position DESC')\n @enter=Refinery::Entertainments::Entertainment.order('position DESC')\n @opinion=Refinery::OpinionMainpages::OpinionMainpage.order('position DESC')\n @money=Refinery::Lives::Life.order('position DESC')\n @tech=Refinery::Technologies::Technology.order('position DESC')\n @world=Refinery::Worlds::World.order('position DESC')\n @random=Refinery::Randoms::Random.order('position DESC')\n \n \n end",
"def continue\n fail 'This is the last page' unless continue?\n\n action = @action.merge(@metadata.fetch('continue'))\n\n self.class.new(action, merge_responses(JSON.parse(action.perform)))\n end",
"def home\n redirect_to action: :index\n end",
"def index\n if params[:goto]\n student = Student.find_by_name(params[:goto])\n redirect_to student and return if student\n student = Student.find_by_number(params[:goto])\n redirect_to student and return if student\n redirect_to students_path and return\n end\n do_it(:order,'number')\n do_it(:per,50)\n \n @students = Student\n @students = Course.find(params[:course_id]).students if params[:course_id]\n @students = @students.where(klass_id:Grade.find(params[:grade_id]).klasses.collect(&:id)) if params[:grade_id]\n @students = @students.where(klass_id:params[:klass_id]) if params[:klass_id]\n @students = @students.where(paixuzi:params[:paixuzi]) if params[:paixuzi]\n @students = @students.where(surname:FamilyName.find(params[:surname_id]).hanzi) if params[:surname_id]\n @students = @students.where(number_prefix:params[:number_prefix]) if params[:number_prefix]\n @students = @students.where(klass2_id:params[:klass2_id]) if params[:klass2_id]\n @students = @students.order(params[:order])\n @students = @students.page(params[:page]).per(params[:per])\n @order = params[:order]\n end",
"def do_not\n redirect_to(workout_path(@workout), alert: t('.already_done')) if @workout.done?\n redirect_to(workout_path(@workout), alert: t('.already_skipped')) if @workout.skipped?\n @workout.skipped = true\n @workout.weight_before = current_user.latest_weight_before\n end",
"def homepage\n end",
"def homepage\n end",
"def landing\n end",
"def landing\n end",
"def test_specifics_index_views\n ebay_singles = generate_ebay_items_with_size(25, \"7\\\"\")\n ebay_singles.map {|ebay_item| ebay_item.save}\n get :singles, :page => 1, :sort => ENDTIME, :order => DESC\n check_index_items(ebay_singles.reverse[0..19])\n\n ebay_eps = generate_ebay_items_with_size(25, \"10\\\"\")\n save_ebay_items(ebay_eps)\n get :eps, :page => 1\n check_index_items(ebay_eps.reverse[0..19])\n\n ebay_lps = generate_ebay_items_with_size(25, \"LP\")\n save_ebay_items(ebay_lps)\n get :lps, :page => 1\n check_index_items(ebay_lps.reverse[0..19])\n\n other_items = generate_ebay_items_with_size(25, \"something else\")\n save_ebay_items(other_items)\n get :other, :page => 1\n check_index_items(other_items.reverse[0..19])\n end",
"def index\n @all_entries = Entry.all\n @max_pages = @all_entries.max_pages\n @recent = @all_entries.page\n\n if page_params[:page]\n\n if page_params[:page].to_i > @max_pages.to_i or page_params[:page].to_i < 1\n redirect_to root_url, notice: 'Page does not exist. Only 1 through ' + @max_pages.to_s + ' pages exist.'\n end\n\n @entries = @all_entries.page(page_params[:page].to_i)\n @current_page = page_params[:page]\n else\n @entries = @all_entries.page\n @current_page = 1\n end\n\n end",
"def skip?\n @skip\n end"
] |
[
"0.6603064",
"0.6154686",
"0.6127471",
"0.6127471",
"0.612652",
"0.60483104",
"0.59507567",
"0.5941843",
"0.5864651",
"0.5864651",
"0.5864651",
"0.5864651",
"0.58514",
"0.5786248",
"0.57743627",
"0.57743627",
"0.5756998",
"0.5711406",
"0.57079804",
"0.5692506",
"0.56792283",
"0.5611078",
"0.5604809",
"0.55859447",
"0.55831957",
"0.5580129",
"0.5569321",
"0.55540085",
"0.553758",
"0.5532357",
"0.5529319",
"0.5523192",
"0.55120766",
"0.5502683",
"0.54658777",
"0.54657966",
"0.5465775",
"0.5447747",
"0.544389",
"0.5435072",
"0.5416494",
"0.53957355",
"0.5380646",
"0.5375418",
"0.5368503",
"0.5368503",
"0.5362964",
"0.5347323",
"0.5346506",
"0.5343404",
"0.53405946",
"0.5328842",
"0.53084797",
"0.530756",
"0.5301917",
"0.52854615",
"0.5269956",
"0.52649057",
"0.52648383",
"0.52629703",
"0.5262118",
"0.525516",
"0.5246598",
"0.5245319",
"0.52403206",
"0.5235628",
"0.5233769",
"0.52321476",
"0.5228184",
"0.5227939",
"0.52210975",
"0.5218636",
"0.5218636",
"0.521559",
"0.5215419",
"0.5210861",
"0.5203304",
"0.5202795",
"0.51964134",
"0.51958007",
"0.5195408",
"0.5177673",
"0.51769334",
"0.5173477",
"0.5173477",
"0.5173477",
"0.51648873",
"0.516436",
"0.516436",
"0.51604885",
"0.51569533",
"0.5154924",
"0.5152573",
"0.5149983",
"0.5148111",
"0.5148111",
"0.51461965",
"0.51461965",
"0.514471",
"0.5143925",
"0.5137902"
] |
0.0
|
-1
|
shorten. pass: url: the url to be shortened So to use: twurl = Shorty::Truwl.new twurl.shorten('
|
def shorten(url)
query = { :'link[url]' => url }
self.class.post("/links", :query => query)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def shorten(url)\n bitly_url = \"http://api.bit.ly/shorten?version=2.0.1&login=#{BITLY_LOGIN}&apiKey=#{BITLY_API_KEY}&longUrl=#{CGI::escape(url)}\"\n resp = open(bitly_url).read\n JSON.parse(resp)['results'][url]['shortUrl']\n rescue\n logger.debug(\"Unable to generate Bit.ly url for #{url}\")\n nil\n end",
"def short_url\n @short_url ||= client.shorten(long_url: url).link\n rescue => e\n Rails.logger.warn(\"Could not shorten bit.ly url #{e.message}\")\n url\n end",
"def shorten(opts, url)\n request(\n :get,\n \"#{opts['a']}#{SHORTEN_URL}?action=shorten&url=#{URI.escape(url)}&key=#{opts['t']}\"\n ).sub(/awau\\.moe/, opts['u'])\n end",
"def short_link\n UrlShort::IsGd.shorten @link\n end",
"def shorten(url, full = true)\n self.class.get_and_parse_shorten(url, full)\n end",
"def shorten\n request = {\n body: { longUrl: url }.to_json,\n headers: { 'Content-Type' => 'application/json' },\n query: { key: api_key, \n access_token: access_token }\n }\n\n request.merge!({ http_proxyaddr: proxy.host, \n http_proxyport: proxy.port, \n http_proxyuser: proxy.user, \n http_proxypass: proxy.password }) if proxy\n\n Timeout::timeout(timeout) do\n # submit the url to Goo.gl\n result = self.class.post(\"/urlshortener/v1/url\", request)\n # return the response id or the url\n result.parsed_response[\"id\"] || url\n end\n # if a problem occurs\n rescue Timeout::Error, JSON::ParserError => e\n # just return the original url\n url\n end",
"def shorten\n result = url\n \n begin \n if url.size > 18 && !/http:\\/\\/snipr.com.*/.match(url)\n using(rdr = StreamReader.new(request.get_response.get_response_stream)) { \n result = rdr.read_to_end.to_s\n } \n end\n rescue Exception => e\n #catch all errors and just return the regular url\n end\n \n res = ((result.size >= url.size || result.empty?) ? url.ensure_http : result).to_s\n logger.debug(\"*** SniprUrl: Shortened url from: #{url} to #{res}\")\n res\n end",
"def shorten(url)\n xml = SimpleHttp.get(\"#{API_URL}/shorten?url=#{CGI::escape(url)}&service=#{key}&format=xml\")\n doc = REXML::Document.new(xml)\n\n result = doc.elements[\"result\"]\n\n if result.elements[\"status\"].text == \"ok\"\n result.elements[\"url\"].text\n else\n raise result.elements[\"description\"].text\n end\n end",
"def shorten(long_url, opts={})\n query = { :longUrl => long_url }.merge(opts)\n response = get('/shorten', :query => query)\n return Bitly::V3::Url.new(self, response['data'])\n end",
"def shorten(long_url, options={})\n response = get(:shorten, { :longUrl => long_url }.merge(options))\n return Bitlyr::Url.new(self, response)\n end",
"def putShortenurl( url)\n params = Hash.new\n params['url'] = url\n return doCurl(\"put\",\"/shortenurl\",params)\n end",
"def get_short_url(link)\n client = Bitly.client\n shortened_url = client.shorten(link)\n return shortened_url.short_url \n end",
"def shorten_link(url)\n uri = URI.parse(\"http://localhost:3000/shorten\")\n params = {\"url\": url}\n uri.query = URI.encode_www_form(params)\n JSON.parse(Net::HTTP.get(uri))\nend",
"def shorten_urls\n @status = (@status.split(\" \").collect do |word|\n if word =~ URI::regexp and word.length > 30 then\n # using tinyurl\n # NOTE: look into retwt.me, they have a simple api (w/o auth) and provide analysis\n (Net::HTTP.post_form URI.parse('http://tinyurl.com/api-create.php'),{\"url\" => word}).body\n else\n word\n end\n end).join(\" \")\n end",
"def shorten(url)\n if @access_token.nil?\n login { shorten(url) } \n return self\n end\n\n params = get_request_parameters(url)\n request = EM::HttpRequest.new(API_SHORTEN_URL).get(params)\n request.callback(&method(:on_success))\n request.errback(&method(:on_error))\n self\n end",
"def shorten(long_url, ops={})\n\t\t\treturn nil unless long_url\n return execute_post('shorten', :link) do |params|\n params[:long_url] = long_url\n params.merge!(ops)\n end\n\t\tend",
"def getShortenurl( id)\n params = Hash.new\n params['id'] = id\n return doCurl(\"get\",\"/shortenurl\",params)\n end",
"def shorten\n\t\tcharacters = [*\"0\"..\"9\", *\"A\"..\"Z\", *\"a\"..\"z\"]\n\n\t\t@short_url = (0..6).map{characters.sample}.join\n\t\tself.short_url = @short_url\n\tend",
"def shorten\n\t\trange = [*'0'..'9',*'A'..'Z',*'a'..'z']\n self.short_url = Array.new(7){range.sample}.join\n self.save\n\tend",
"def shorten\n\t\n\t\tself.short_url = SecureRandom.urlsafe_base64(4)\n\tend",
"def shorten(long_url)\n http_response = @httpclient.get_content(build_url(\"shorten\", \"longUrl=#{CGI::escape(long_url)}\"))\n data = JSON.parse(http_response)\n raise BitlyError.new(data[\"errorMessage\"]) unless data[\"statusCode\"] == \"OK\"\n data[\"results\"][long_url]\n end",
"def shorten(url, key=nil)\n begin\n shorten!(url, key)\n rescue => e\n nil\n end\n end",
"def short_url\n return nil if url.nil?\n url.gsub(\"http://\",\"\").gsub(\"www.\", \"\")\n end",
"def shorten(url)\n params = { :query => { :url => url } }\n request = EM::HttpRequest.new(API_URL).post(params)\n request.callback(&method(:on_success))\n request.errback(&method(:on_error))\n self\n end",
"def shorten\n\tself.short_url = SecureRandom.hex(3)\n\tend",
"def shorten_url(url)\n pattern = /<a.*>(\\S*)<\\/a>/um\n url =~ pattern\n (url = url.sub(/>.*#{$1}.*</um, \">les mer<\")) unless $1 == nil\n\n # Some line-broken or complex urls don't work. For now we just null them to \"\" and\n # hope people check the NAF calendar.\n if(url =~ /les mer/)\n return url\n else\n return \"\"\n end\n end",
"def unshorten(url, opts= {})\n options = {\n max_level: opts.fetch(:max_level, 10),\n timeout: opts.fetch(:timeout, 2),\n use_cache: opts.fetch(:use_cache, true)\n }\n url = (url =~ /^https?:/i) ? url : \"http://#{url}\"\n __unshorten__(url, options)\n end",
"def short\n alexa_rank = alexa_rank params[:url]\n host = get_domain params[:url]\n host = host.split \".\"\n domain = host.count >= 3 ? host[host.count - 3] : host[host.count - 2]\n @url = @user.url.create url: params[:url], alexa_rank: alexa_rank, domain: domain\n @url.save!\n render json: {url_short: @url.url_short}\n end",
"def shorten\n\t\t self.short_url = SecureRandom.hex(3)\n\tend",
"def shorten_with_bitly(long_url)\n # long URL will be sth like:\n # http://springerquotes.heroku.com/article/doi:10.1186/1477-7819-1-29#h[AtmWaa,7,AraRwg,13,IatDaw,1,GcoNwm,4]\n\n # generate the quote URL like this:\n # http://springerquotes.heroku.com/quotes/doi:10.1186/1471-2105-7-126?quotes=h[TmeWta,2,5,6,witFas,2]\n # [\"http\",\n # nil,\n # \"localhost\",\n # \"9292\",\n # nil,\n # \"/article/doi:10.1186/1471-2105-7-126\",\n # nil,\n # nil,\n # \"h[TmeWta,2,5,6,witFas,2]\"]\n uri_elements = URI.split(long_url)\n quote_url = \"http://springerquotes.heroku.com/#{uri_elements[5].gsub(/^\\/article/,\"quotes\")}?quotes=#{uri_elements[8]}\"\n\n puts \"Creating bit.ly URL for #{quote_url}\"\n\n # shorten URL\n yql_query = \"\n SET login = '#{Bitly_username}' ON bit.ly;\n SET apiKey = '#{Bitly_apikey}' ON bit.ly;\n SELECT data FROM bit.ly.shorten WHERE longUrl='#{quote_url}';\n \"\n yql_query = YqlSimple.query(yql_query)\n\n begin\n short_url = yql_query[\"query\"][\"results\"][\"response\"][\"data\"][\"url\"]\n rescue Exception => ex\n short_url = nil\n end\n\n return short_url\n end",
"def shortener\n\t\tcharacters = [*\"0\"..\"9\", *\"A\"..\"Z\", *\"a\"..\"z\"]\n\n\t\t@short_url = (0..6).map{characters.sample}.join\n\t\tself.short_url = @short_url\n\tend",
"def shorten\n self.url_short = SecureRandom.hex(5)\n end",
"def shorten\n self.url_short = SecureRandom.hex(5)\n end",
"def shorten_url\n\t\t# generate 7 random numbers from 0-9 and a-z\n\t\tself.short_url = rand(36**7).to_s(36) # [0,6] # use this to ensure 7 characters\n\n\t\t# to include A-Z\n\t\t# require 'base62'\n\t\t# self.short_url = rand(36**7).base62_encode\n\n\t\t# self.short_url = SecureRandom.hex(10)\n\tend",
"def shorten_url(url)\n res = http_post(\"http://crash.io\", :url => url)\n if res.status == 201\n res.headers['location']\n else\n url\n end\n rescue TimeoutError\n url\n end",
"def shorten_link\n # http://stackoverflow.com/questions/88311/how-best-to-generate-a-random-string-in-ruby\n o = [('a'..'z'), ('A'..'Z')].map(&:to_a).flatten\n string = (0...6).map { o[rand(o.length)] }.join\n self.short_url = \"http://www.sho.rt/#{string}\"\n end",
"def sanitize\n \tself.original_url.strip!\n \tself.sanitize_url = self.original_url.downcase.gsub(/(https?:\\/\\/)|(www\\.)/, \"\")\n \tself.sanitize_url = \"http://#{self.sanitize_url}\"\n\n \n start = 8\n final = self.sanitize_url.length\n\n while start <= final do\n sanitize_url[start] == ' ' ? sanitize_url[start] = '-' : sanitize_url[start] = sanitize_url[start] #change spaces for '-'\n break if sanitize_url[start] == '/' #break if '/' is found\n start +=1\n end\n\n self.sanitize_url = sanitize_url[0..start] #cut the string for creating the shortened_url\n self.short_url = sanitize_url + short_url #save the final shortened_url on the short_url's field\n end",
"def generate_short_url(long_url)\n\t @shortcode = random_string 5\n\t \n\t su = ShortURL.first_or_create(\n\t { :url => long_url }, \n\t {\n\t :short_url => @shortcode,\n\t :created_at => Time.now,\n\t :updated_at => Time.now\n\t })\n\t \n\t @shortenedURL = get_site_url(su.short_url)\n\tend",
"def shorten!(url, key=nil)\n begin\n key ? named_url(url, key) : autoname_url(url)\n rescue => e\n @error = e and raise\n end\n end",
"def set_shorten_url\n @shorten_url = ShortenUrl.find(params[:id])\n end",
"def generate_short_url\n url = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond).to_s(36)\n old_url = Link.where(short_url: url).last\n if old_url.present? \n self.generate_short_url\n else\n self.short_url = url\n end\n end",
"def generate_short_url(base_url)\n build_shorten_url.update( uniq_id: shorten, expired_at: Time.now.utc + 1.year ) unless shorten_url\n shorten_url.link(base_url)\n end",
"def full_shortened_url(base)\n base + '/' + short_url\n end",
"def create_short_url(url_params) \n url = Url.new(url_params)\n url.suffix= url.create_suffix(url_params[:longurl],0)\n while url.unique(url.suffix) == false\n url.suffix = url.create_suffix(url_params[:longurl],1)\n end\n domain = Domainatrix.parse(url_params[:longurl]).domain + '.' + Domainatrix.parse(url_params[:longurl]).public_suffix\n short_domain = ShortDomain.where(domain: domain).first[:prefix]\n url.shorturl = \"http://\" + short_domain +'/'+ url.suffix\n if url.save\n return url\n else\n return nil\n end\n end",
"def convert_long_url_to_short_url\n if params[:long_url] == \"\"\n flash[:Error] = \"Please Enter all Details\"\n redirect_to urls_long_url_to_short_url_path\n else\n params[:long_url] = params[:long_url].strip\n @result = shorten_url(url_params)\n render '/urls/show'\n end\n end",
"def shorter_url\n\t\tself.short_url = SecureRandom.base64(10)\n\tend",
"def create_short_url(original_url = nil)\n params = {body: {originalURL: original_url, domain: @short_domain}.to_json, headers: {\"Authorization\" => @short_api_key}}\n response = self.class.post(\"/links\", params)\n @short_url = JSON.parse(response.body)[\"shortURL\"]\n response\n end",
"def create_short_url\n rand_url = ('a'..'z').to_a.shuffle[0..5].join\n self.short_url = \"#{rand_url}\"\n end",
"def url_shortener(full_uri)\n mapper = UrlMapper.find_by_original_url(full_uri)\n \n if mapper\n string = mapper.short_url\n else\n string = \"/\"\n 5.times { string << (i = Kernel.rand(62); i += ((i < 10) ? 48 : ((i < 36) ? 55 : 61 ))).chr }\n begin\n UrlMapper.create!({:short_url => string, :original_url => full_uri})\n rescue\n end\n end\n \"#{APP_CONFIG['url_shortener']}#{string}\"\n end",
"def shorten_url\n if @url.save\n headers 'Location' => url(@url.path)\n halt 201, \"Created #{url(@url.path)}\"\n else\n halt 406, \"#{@url.errors.full_messages.join(\".\\n\")}\"\n end\n end",
"def base_url\n 'http://ow.ly/api/1.1/url/shorten'\n end",
"def shortened_url_analytics(short_url)\n response = expand_url_request(short_url, true)\n get_api_response(response)\n end",
"def generate_short_url(url_id)\n # Base62 alphabet to be used\n alphabet_array = [*'a'..'z', *'A'..'Z', *'0'..'9']\n shorturl = []\n while url_id.to_i.positive?\n shorturl.push(alphabet_array[url_id % 62])\n url_id /= 62\n end\n new_url = shorturl.reverse.join\n\n # Check short_url doesn't exist in the database. If short_url exists, we generate a new url\n url_exist = UrlShortener.find_by_short_url(new_url)\n return new_url if url_exist.blank?\n\n generate_short_url(url_id)\n end",
"def shortened\n @shortened ||= shorten\n end",
"def update_short_url\n uniq_key = Digest::MD5.hexdigest(\"#{self.id()}\").slice(0..6) \n update_column(:short_url, BASE_SHORT_URL + uniq_key)\n true\n end",
"def short\n Rails.application.routes.url_helpers.short_url(short_url: self.short_url)\n end",
"def short_url\n \"#{HOST_URL}/#{short_code}\"\n end",
"def generate_short_url\n short_url = unique_url\n\n # check if this is a duplicate\n if ShortenUrl.where(short_url: short_url).exists?\n # try again\n generate_short_url\n else\n self.short_url = short_url\n end\n end",
"def short(url)\n clean_url = UrlSanitizer.sanitize(url)\n key = @@urls.key(clean_url) || create(clean_url)\n end",
"def generate_short_url\n url = ([*('a'..'z'),*('0'..'9')]).sample(UNIQUE_ID_LENGTH).join\n old_url = ShortenedUrl.where(short_url: url).last\n if old_url.present?\n self.generate_short_url\n else\n self.short_url = url\n end\n end",
"def short_url\n self.minified_url = ShortUrlsHelper.url_encode(id.to_i)\n\n if save\n update_title(self.id)\n return true\n end\n\n false\n end",
"def compose(link)\n s = shortener.shorten(link.url)\n \"#{link.title}\\n#{s.short_url}\"\n end",
"def create_shortened_url\n key = self.id - 1\n\n if key == 0\n shortened = ALPHABET[0]\n else\n shortened = ''\n baseLength = ALPHABET.length\n\n until key < 1\n place = key % baseLength\n shortened += ALPHABET[place]\n\n key /= baseLength\n end\n end\n self.shortened = shortened\n self.save\n end",
"def set_shortened_url\n @shortened_url = ShortenedUrl.find(params[:id])\n end",
"def index\n @url = ShortenedUrl.new\n end",
"def retrieve_short_url_to_long_url\n if params[:short_url]==\"\"\n flash[:Error] = \"Please Enter all Details\"\n redirect_to urls_short_url_to_long_url_path\n else\n params[:short_url] = params[:short_url].strip\n @result = short_url(url_params)\n render '/urls/show'\n end\n end",
"def tinyfyurl\n self.tinyurl = Tools.tinyfy(url)\n end",
"def shorten(*urls)\n urls = urls.flatten\n raise OwO::Err::NoContent, 'There is a empty string in your arguments!' if urls.include? ''\n raise OwO::Err::NoContent, 'Theres no URLs provided!' if urls.empty?\n result = urls.flatten.map { |x| OwO::API.shorten(opts, x) }\n result[0] if urls.length == 1 || !urls.first.is_a?(Array)\n end",
"def generate_short_url\n self.update_attribute :short_url, self.class.convert_to_base62(self.id)\n end",
"def perform(short_url_id)\n short_url = ShortUrl.find_by!(id: short_url_id)\n\n begin\n tempfile = URI.open(short_url.full_url)\n document = Nokogiri::HTML.parse(tempfile)\n title = document.title || ''\n short_url.update!(title: title)\n ensure\n # URI.open returns a Tempfile or StringIO object depending on the\n # size of the web page. If a Tempfile object is generated, then\n # it is a good practice to clean up temporary files in an ensure block.\n if tempfile.is_a?(Tempfile)\n tempfile.close\n tempfile.unlink\n end\n end\n end",
"def set_urlshortner\n @urlshortner = Urlshortner.find(params[:id])\n end",
"def shorten_url_params\n params.require(:shorten_url).permit(:original_url)\n end",
"def generate_short_url\n new_short = \"/\" + Faker::Lorem.characters(7)\n until short_url_unique?(new_short)\n new_short = \"/\" + Faker::Lorem.characters(7)\n end\n self.short_url = new_short\n end",
"def set_short_url\n @short_url = ShortUrl.find(params[:id])\n end",
"def set_short_url\n @short_url = ShortUrl.find(params[:id])\n end",
"def set_short_url\n @short_url = ShortUrl.find(params[:id])\n end",
"def set_short_url\n @short_url = ShortUrl.find(params[:id])\n end",
"def create\n \n url_match = params[:url][:url] =~ /\\Ahttp(s?):\\/\\//i\n params[:url][:url] = \"http://\" << params[:url][:url] if url_match.nil?\n \n # find existing url\n @existing_url = Url.find_by_url(params[:url][:url])\n \n if @existing_url.nil?\n @url = Url.new(params[:url])\n id = Url.last.id unless Url.last.nil?\n @url.short_url = Shorten::Base62.to_s(id.nil? ? 1 : id+1)\n p @url\n else\n @url = @existing_url\n end\n\n respond_to do |format|\n if !@existing_url.nil? or @url.save\n format.html { redirect_to @url, notice: 'Url was successfully shortened.' }\n format.json { render json: @url, status: :created, location: @url }\n format.js\n else\n format.html { render action: \"new\" }\n format.json { render json: @url.errors, status: :unprocessable_entity }\n format.js\n end\n end\n end",
"def set_short_url\n @short_url = ShortUrl.find(params[:id])\n end",
"def shorturl\n return nil if self.new_record?\n return self.surl unless self.surl.nil?\n\n self.surl = encode_url\n\n self.save\n return surl\n end",
"def set_shorturl\n @shorturl = Shorturl.find(params[:id])\n end",
"def set_shorturl\n @shorturl = Shorturl.find(params[:id])\n end",
"def set_shorturl\n @shorturl = Shorturl.find(params[:id])\n end",
"def short_url\n @json[\"shortUrl\"]\n end",
"def short_url\n response[\"shortUrl\"]\n end",
"def short_url_algorithm()\n \n unique_id_length = 3\n base64 = Base64.encode64(self.original_url)\n join_url = (base64.split('')).sample(unique_id_length).join()\n safe_url = join_url.gsub(\"+\", \"-\").gsub(\"/\",\"_\")\n \n loop do \n self.short_url = @@URL + safe_url\n \n if Url.find_by_short_url(self.short_url).nil?\n break\n else\n unique_id_length = unique_id_length + 1\n end\n \n end\n \n end",
"def shortened_url_params\n params.require(:shortened_url).permit(:long_url)\n end",
"def set_short_url\n @short_url = ShortUrl.find(params[:short])\n end",
"def generate_short_url(clash_count=0)\n raise \"Too many short URL clashes. Please increase the short url length\" if clash_count == 10\n url = self.sanitize_url\n shortened_url = Digest::MD5.hexdigest(url)[(0+clash_count)..(SHORT_URL_LENGTH+clash_count)]\n url_present = Url.find_by_short_url(shortened_url)\n if(url_present)\n generate_short_url(clash_count+1)\n else\n self.short_url = shortened_url\n end\n end",
"def shorten\n\t\t# range_alpha = [*\"A\"..\"Z\",*\"a\"..\"z\"]\n\t\t# range_int = [*\"0\"..\"9\"]\n\t\t# short_url = (0...3).map{ range_alpha.sample }.join('') \n\t\t# short_url2 = (0...4).map{range_int.sample}.join('')\n\n\t\t# return short_url + short_url2\n\t\treturn SecureRandom.hex(3)\n\tend",
"def easy\n url = params[:url]\n\n # Well, this would be super slow for mainstream processors, but\n # might be good enough for Mom's & Dad's shop\n link = Link.find_by_url(url)\n\n # Oops, we don't have this Url in tables yet\n if link.nil?\n link = Link.new\n link.url = url\n link.save\n end\n\n render :text => SHORT_URL + \"/\" + Base32::Crockford.encode(link.id)\n end",
"def shorten_link\n \t\tinput_link = params[:link][:given_link]\n \t\trender json: shorten_my_link(input_link)\n \tend",
"def get_longurl\n\t\turl_id = get_id_from_short_url params[:short_url]\n\t\turl = Url.find(url_id)\n\t\tjson_response({long_url: \"Long URL for the given Short URL: www.tinyurl/#{params[:short_url]} is: #{url[:long_url]}\"})\n\tend",
"def short_redirect\n env = {\n remote_host: request.env[\"REMOTE_HOST\"],\n remote_addr: request.env[\"REMOTE_ADDR\"],\n http_user_agent: request.env[\"HTTP_USER_AGENT\"],\n http_referer: request.env[\"HTTP_REFERER\"],\n request_uri: request.env[\"REQUEST_URI\"]\n }\n RequestLogger.logg_request(env)\n @link = Link.find_by(url_short: params[:url_short])\n if @link.nil?\n flash[:error] = 'The Shorty you tried to visit does not exist!'\n redirect_to root_path\n else\n redirect_to @link.url\n end\n end",
"def shorten\n\t\tp \"** #{self.id} | #{self.long}\"\n\t\t# self.short = Base64.urlsafe_encode64(\"rudy\" + \"[#{self.id}]\")\n\t\t# self.short = Base64.urlsafe_encode64(\"rudy\" + Time.now.to_i.to_s)\n\t\tself.short = Base64.urlsafe_encode64(Time.now.to_i.to_s + SecureRandom.base64(5))\n\n\t\t# can use SecureRandom\n\n\t\tp \"**** #{self.short}\"\n\n\tend",
"def get_short_url\n\n long_url = params[:long_url]\n\n if long_url.blank? || !long_url.is_valid_url?\n respond_to do |format|\n format.html { redirect_to urls_url, notice: 'Long URL must be in the format http://www.decisiv.com' }\n format.json { render :json => {:error => \"Long URL must be in the format http://www.decisiv.com\"}.to_json, :status => 400 }\n end\n return\n end\n\n short_url = nil\n\n if Url.where(:long_url => long_url).exists?\n\n @url = Url.where(:long_url => long_url).first\n \n respond_to do |format|\n format.html { redirect_to urls_url, notice: 'URL already exists' }\n format.json { render :json => @url.to_json, :status => 400 }\n end\n return\n \n end\n\n\n for i in 0..20 \n\n # generate a random text\n short_url = [*('a'..'z'),*('0'..'9')].shuffle[0,10].join\n\n if RestrictedWord.find_by_fuzzy_word(short_url).count > 0\n next\n end\n\n if Url.find_by_fuzzy_short_url(short_url).count > 0\n next\n end\n\n \n # add it to the database\n @url = Url.new\n @url.long_url = long_url\n @url.short_url = short_url\n \n if @url.save\n\n Url.bulk_update_fuzzy_short_url\n\n respond_to do |format|\n format.html { redirect_to urls_url, notice: 'Short URL created' }\n format.json { render :json => @url.to_json, :status => 200 }\n end\n return\n\n else\n respond_to do |format|\n format.html { render :new }\n format.json { render json: @url.errors, status: :unprocessable_entity }\n end\n return\n\n end\n\n end\n\n respond_to do |format|\n format.html { redirect_to urls_url, notice: 'Error trying to create short URL.' }\n format.json { render :json => {:error => \"Error trying to create short URL.\"}.to_json, :status => 400 }\n end\n\n end",
"def set_url\n @short = Short.find(params[:id])\n end",
"def generate_short_url\n short_url = SecureRandom.urlsafe_base64[0..6]\n short_url\n end",
"def set_url_shortner\n @url_shortner = UrlShortner.find(params[:id])\n end",
"def short_params\n params.require(:short).permit(:url)\n end"
] |
[
"0.80530053",
"0.80467165",
"0.79164016",
"0.7848189",
"0.7842859",
"0.7826023",
"0.78101313",
"0.7805245",
"0.7697066",
"0.768375",
"0.76509374",
"0.7628345",
"0.7602497",
"0.75701636",
"0.7517032",
"0.7509427",
"0.75025225",
"0.743538",
"0.7422505",
"0.74091196",
"0.74085885",
"0.7400851",
"0.7373216",
"0.7326584",
"0.73047435",
"0.72897655",
"0.7275532",
"0.7273807",
"0.72548175",
"0.7253807",
"0.724664",
"0.7233322",
"0.7233322",
"0.7195393",
"0.7124515",
"0.710976",
"0.69284207",
"0.6900064",
"0.68887347",
"0.68772286",
"0.6874379",
"0.6851963",
"0.6827591",
"0.6820311",
"0.68131244",
"0.6729227",
"0.67255026",
"0.67213154",
"0.67119354",
"0.67112046",
"0.6710387",
"0.670107",
"0.6686069",
"0.6612746",
"0.6611566",
"0.6588675",
"0.6567661",
"0.65661526",
"0.6562044",
"0.6560383",
"0.6551357",
"0.6527826",
"0.65143365",
"0.6491865",
"0.64872473",
"0.64804673",
"0.6467706",
"0.64477456",
"0.64046013",
"0.6400823",
"0.63926136",
"0.63796514",
"0.63704646",
"0.63694924",
"0.63694924",
"0.63694924",
"0.63694924",
"0.6362159",
"0.63618594",
"0.63489205",
"0.63473684",
"0.63473684",
"0.63473684",
"0.6334637",
"0.633406",
"0.63201725",
"0.63151395",
"0.63062036",
"0.6294561",
"0.62914014",
"0.62821645",
"0.6278951",
"0.6278053",
"0.62745816",
"0.62524843",
"0.624728",
"0.6244408",
"0.6238823",
"0.62277627",
"0.62158144"
] |
0.7600482
|
13
|
Binary Search O(log n)
|
def search(an_array,item)
first = 0
last = an_array.length - 1
while first <= last
i = (first + last) / 2
if an_array[i] == item
return
# 6 < 5
# first = 6
elsif an_array[i] < item
first = i + 1
elsif an_array[i] > item
last = i - 1
else
# 6 > 5
# last = 5
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def binary_search(numbers, element)\n min = 0\n max = numbers.size - 1\n\n index = nil\n\n while index.nil? do\n middle_element_index = (min + max) / 2 # Every iteration (N / 2) = O(log n)\n middle_element = numbers[middle_element_index] \n \n if element < middle_element\n max = middle_element_index\n elsif element > middle_element\n min = middle_element_index\n elsif element == middle_element\n index = middle_element_index\n end\n end\n\n index\nend",
"def binary_search(a, key)\n low = 0\n high = a.length - 1\n\n while low <= high\n mid = low + ((high - low) / 2)\n\n return mid if a[mid] == key\n\n if key < a[mid]\n high = mid - 1\n else\n low = mid + 1\n end\n end\n\n return -1\nend",
"def binary_search(ary, value); end",
"def bin_search(arr, key)\n low = 0\n high = arr.length - 1\n while high >= low do\n mid = low + (high - low) / 2\n if arr[mid] > key\n high = mid - 1\n elsif arr[mid] < key\n low = mid + 1\n else\n return mid\n end\n end\n return 0\nend",
"def binary_search(binaryMatrix,start,last,n,row)\n\tif start > last\n\t\treturn -1\n\tend\n\tmid = start + (last-start)/2\n\tif binaryMatrix.get(row,mid) == 1\n\t\tif binaryMatrix.get(row,mid-1) == 0 || mid == 0\n\t\t\treturn mid\n\t\telse\n\t\t\tbinary_search(binaryMatrix,start,mid-1,n,row)\n\t\tend\t\n\telsif binaryMatrix.get(row,mid) == 0\n\t\tbinary_search(binaryMatrix,mid+1,last,n,row)\n\tend\nend",
"def binary_search(array, target)\n lower_bound = 0\n upper_bound array.length - 1\n while lower_bound <= upper_boud do\n midpoint = (upper_bound + lower_bound) / 2\n value_at_midpoint = array[midpoint]\n if target == value_at_midpoint\n return midpoint\n elsif target < value_at_midpoint\n upper_bound = midpoint - 1\n elsif target > value_at_midpoint\n lower_bound = midpoint + 1\n end\n end\n return nil\nend",
"def binary_search(target, array)\r\n\t#Your code here\r\n\tindex = array.length / 2\r\n\tlo = 0\r\n\thi = array.length - 1\r\n\twhile array[index] != target && array.include?(target)\r\n\t\tif array[index] > target\r\n\t\t\thi = index - 1\r\n\t\t index = (lo + hi) / 2\r\n\t\telsif array[index] < target\r\n\t\t\tlo = index + 1\r\n\t\t\tindex = (lo + hi) / 2\r\n\t\tend\r\n\tend\r\n\tif array[index] == target\r\n\t\treturn index\r\n\telse\r\n\t\treturn -1\r\n\tend \r\nend",
"def binary_search_internal(value)\n return [false, 0] if @inner.size == 0\n left = 0\n right = @inner.size - 1\n return [false, 0] if value < @inner[left]\n return [false, right + 1] if value > @inner[right]\n while left <= right\n middle = (left + right) / 2\n if @inner[middle] == value\n return [true, middle]\n elsif value < @inner[middle]\n right = middle - 1\n else\n left = middle + 1\n end\n end\n return [false, left]\n end",
"def binary_search(arr, key)\n low = 0\n high = arr.length - 1\n\n while low <= high\n mid = low + (high - low) / 2\n\n return mid if arr[mid] == key\n\n arr[mid] > key ? high = mid - 1 : low = mid + 1\n end\n\n return -1\nend",
"def bin_search(x, a, b)\r\n mid = (a + b) / 2\r\n sq = mid ** 2\r\n \r\n if a == b || sq == x\r\n mid\r\n elsif sq > x\r\n bin_search(x, a, mid - 1)\r\n else\r\n (mid + 1) ** 2 > x ? mid : bin_search(x, mid + 1, b)\r\n end\r\nend",
"def binary_search(arr, target)\n return nil if arr.empty?\n probe_index = arr.size / 2\n probe_ele = arr[probe_index]\n\n case probe_ele <=> target\n when 1\n left_arr = arr.take(probe_index) \n return binary_search(left_arr,target)\n when 0 \n return probe_index\n when -1\n compensated_index = (probe_index + 1)\n right_arr = arr.drop(compensated_index)\n return nil if binary_search(right_arr,target).nil?\n return binary_search(right_arr,target) + compensated_index\n end\nend",
"def binary_search(array, value, from=0, to=nil)\n to = array.count - 1 unless to\n mid = (from + to) / 2\n \n if value < array[mid]\n return binary_search(array, value, from, mid - 1)\n elsif value > array[mid]\n return binary_search(array, value, mid + 1, to)\n else\n return mid\n end\nend",
"def binary_search(a, key)\n# At every step, consider the array between low and high indices\n# Define initial low and high indices \n low = 0\n high = a.length - 1\n\n\n# If low value is less or equal to high value, calculate the mid index.\n while low <= high\n mid = low + ((high - low) / 2)\n\n# If the element at the mid index is the key, return mid.\n if a[mid] == key\n return mid\n end\n\n# If the element at mid is greater than the key, then change the index high to mid - 1.\n# The index at low remains the same.\n if key < a[mid]\n high = mid - 1\n\n# If the element at mid is less than the key, then change low to mid + 1. The index at high remains the same.\n else\n low = mid + 1\n end\n end\n\n# Through interations, the low indice will be larger than the high indice if the key doesn’t exist, so -1 is returned.\n return -1\nend",
"def rec_bin_search(array, target)\n return nil if array.length == 0\n\n midpoint = array.length / 2\n\n return midpoint if array[midpoint] == target\n\n if target < array[midpoint]\n rec_bin_search(array.take(midpoint), target)\n else\n top = rec_bin_search(array.drop(midpoint + 1), target)\n top == nil ? nil : top + (midpoint + 1)\n end\nend",
"def binary_search_iterative(array, target)\n# declare variables for low and high positions\nlow_index = 0\nhigh_index = array.length - 1\nmid_index = (high_index + low_index) / 2\n\n# while the low is less than the high\nwhile low_index <= high_index do\n\n return mid_index if target == array[mid_index]\n\n puts \"#{low_index} #{mid_index} #{high_index}\"\n\n if low_index == mid_index\n return high_index\n elsif target > array[mid_index]\n # move lower bound up to mid, recalculate new mid\n low_index = mid_index\n # set the high halfway between\n mid_index = (low_index + high_index) / 2\n elsif target < array[mid_index]\n # move upper bound to mid, recalculate new mid\n high_index = mid_index\n mid_index = (low_index + high_index) / 2\n end\n end\nend",
"def binary_search_rec(a, key, low, high)\n# At every step, consider the array between low and high indices\n# When low is greater than high, the key doesn’t exist and -1 is returned.\n if low > high\n return -1\n end\n\n\n# Calculate the mid index.\n mid = low + ((high - low) / 2)\n\n# If the element at the mid index is the key, return mid.\n if a[mid] == key\n return mid\n\n# If the element at mid is greater than the key, then change the index high to mid - 1.\n# The index at low remains the same.\n elsif key < a[mid]\n return binary_search_rec(a, key, low, mid - 1)\n else\n# If the element at mid is less than the key, then change low to mid + 1. The index at high remains the same.\n return binary_search_rec(a, key, mid + 1, high)\n end\nend",
"def binary_search(length, prime)\r\n\r\nend",
"def bin_search(target,array)\n lo = 0\n hi = array.length - 1\n mid = (lo+hi)/2\n while lo <= hi\n if array[mid] > target\n hi = mid-1\n mid = (lo+hi)/2\n elsif array[mid] < target\n lo = mid+1\n mid = (lo+hi)/2\n else\n return mid\n end\n end\n return -1\nend",
"def binary_search(array, length, value_to_find)\n # take the length and divide in half,\n # start_index = 0\n # end_index = length - 1\n # midpoint = length / 2\n # until start_index > end_index\n #\n # end\n\nend",
"def binary_search(array, key, low=0, high=array.size-1) \n return -1 if low > high \n mid = (low + high) / 2 \n return mid if array[mid]==key \n if array[mid] > key \n high = mid - 1 \n else \n low = mid + 1 \n end \n binary_search(array, key, low, high) \nend",
"def bin_search(d, arr)\n middle = arr.length / 2\n i = 0\n j = arr.length - 1\n \n while i < j\n if arr[middle] == d\n return true\n elsif arr[middle] < d\n i = middle + 1\n middle = i + j / 2\n else\n j = middle - 1\n middle = i + j / 2\n end\n end\n return false\nend",
"def binary_search(a, key)\n return binary_search_rec(a, key, 0, a.length - 1)\nend",
"def use_binary_search(list, item)\r\n low = 0\r\n high = list.length - 1\r\n while low <= high\r\n mid = (low + high)\r\n guess = list[mid]\r\n if guess == item\r\n return mid\r\n end\r\n if guess > item\r\n high = mid - 1\r\n else\r\n low = mid + 1\r\n end\r\n end\r\n return nil\r\nend",
"def binary_search(collection, value)\n low = 0\n high = collection.length\n if low >= high\n return \"not found\"\n end\n\n mid = (high / 2).ceil\n\n if collection[mid] == value\n return collection[mid]\n elsif collection[mid] < value\n binary_search(collection[(mid+1)...high], value)\n else\n binary_search(collection[low...mid], value)\n end\nend",
"def binary_search(array, target)\n lower_bound = 0\n upper_bound = array.length - 1\n while lower_bound <= upper_bound\n midpoint = (lower_bound + upper_bound) / 2\n value_at_midpoint = array[midpoint]\n if target = value_at_midpoint\n return midpoint\n elsif target > value_at_midpoint\n lower_bound = midpoint + 1\n elsif target < value_at_midpoint\n upper_bound = midpoint - 1\n end\n end\n return nil\nend",
"def binary_search(array, length, value_to_find)\n low_index = 0\n high_index = length - 1\n search_position = (low_index + length / 2)\n found = false\n ((Math.log2(length).to_i) + 1).times do #Adds 1 to account for lengths where the actual log2 is a decimal number.\n unless found == true\n if array[search_position] == value_to_find\n found = true\n return found\n elsif array[search_position] < value_to_find\n low_index = search_position\n search_position = (low_index + (high_index + 1)) / 2\n elsif array[search_position] > value_to_find\n high_index = search_position\n search_position = (low_index + high_index) / 2\n end\n end\n end\n return found\nend",
"def bsearch(arr, target)\n return nil if arr.length == 1 && arr[0] != target\n mid_i = arr.length / 2\n return mid_i if arr[mid_i] == target\n\n low_arr = arr[0...mid_i]\n high_arr = arr[mid_i+1..-1]\n\n if arr[mid_i] > target\n bsearch(low_arr, target) \n elsif bsearch(high_arr, target) != nil\n low_arr.length + 1 + bsearch(high_arr, target)\n end\n\nend",
"def binarySearch(a, value)\n # Precondition: lst must be sorted asc (smaller first).\n\n # Searching boundaries (all vector)\n p = 0 # left limit (inclusive)\n r = a.length - 1 # right limit (inclusive)\n\n # Optimization\n # Asses that value may actually be in the array: Array range is a[0]..a[-1]\n # Array must be not empty\n if r < 0 or value < a[p] or value > a[r] then\n return nil # nil inplace of -1 to match ruby std\n end\n\n while p <= r do\n q = (p+r)/2\n if a[q] == value\n return q\n end\n if a[q] > value\n # then value is in a[p]...a[q]\n r = q-1\n else\n # then value is in a[q]...a[r]\n p = q+1\n end\n end\n\n return nil # nil inplace of -1 to match ruby std\nend",
"def binary_search(arr, target)\n return nil if !arr.include?(target)\n middle_ele = arr[arr.length / 2]\n middle_idx = arr.length / 2\n if target == middle_ele\n return middle_idx\n elsif target > middle_ele\n binary_search(arr[middle_idx+1..-1], target) + arr[0..middle_idx].length\n else\n binary_search(arr[0...middle_idx], target)\n end\nend",
"def binary_search(array, value, from=0, to=nil)\n if to == nil\n to = array.count - 1\n end\n\n mid = (from + to) / 2\n\n if value < array[mid]\n return binary_search array, value, from, mid - 1\n elsif value > array[mid]\n return binary_search array, value, mid + 1, to\n else\n return mid\n end\nend",
"def binary_search(array, value, from=0, to=nil)\n if to == nil\n to = array.count - 1\n end\n\n mid = (from + to) / 2\n\n if value < array[mid]\n return binary_search array, value, from, mid - 1\n elsif value > array[mid]\n return binary_search array, value, mid + 1, to\n else\n return mid\n end\nend",
"def binary_search(key,array)\n\tlow = 0\n\thigh = array.sort.length - 1\n\treturn -1 if low>high\n\tmid = (low+high)/2\n\treturn mid if array[mid]==key\n\t\tif array[mid]>key\n\t\t\thigh=mid-1\n\t\t\tmid=(low+high)/2\n\t\telse\n\t\t\tlow=mid+1\n\t\t\tmid=(low+high)/2\n\t\tend\nend",
"def binary_search(arr, item)\n #assign parts of the array by beginning and end\n\n #Envoy of the beginning\n left = 0\n #Envoy of the End\n right = arr.length - 1\n\n # while the item is not found\n # (since you are converging from the changing range, high to low)\n while left <= right\n #set a mid point to be used in the middle of any range created by high & low\n mid = (left + right) / 2\n\n if arr[mid] == item\n return mid\n end\n\n if arr[mid] > item\n right = mid - 1\n else\n left = mid + 1\n end\n end\n\n return nil\n\nend",
"def ubiquitous_binary_search(a,key) # a is the array and key is the value we want to search\n lo= 0\n hi = a.length-1\n \n while(hi-lo>1)\n mid = lo + (hi-lo)/2\n \n if a[mid]<=key\n lo=mid\n else\n hi=mid\n end\n end\n \n if (a[lo]== key)\n return lo\n elsif (a[hi]== key)\n return hi\n else\n return \"value not found\"\n end\nend",
"def binary_search(array, length, value_to_find)\n high = length\n low = 0\n length.times do\n guess = (low + high) / 2\n return true if array[guess] == value_to_find\n return false if high - low <= 1\n array[guess] < value_to_find ? low = guess : high = guess\n end\nend",
"def binary_search(array, target)\n temp = array.sort\n middle = temp.length / 2\n first = 0\n last = temp.length - 1\n while first < last\n if temp[middle] == target\n return middle\n elsif temp[middle] < target\n first = middle + 1\n middle = (first + last) / 2\n else\n last = middle - 1\n middle = (first + last) / 2\n end\n end\n return -1\nend",
"def bsearch(arr, num)\n return nil if !arr.include?(num)\n\n mid_idx = arr.length / 2\n if arr[mid_idx] == num\n return mid_idx\n elsif arr[mid_idx] > num\n lower_half = arr[0...mid_idx]\n bsearch(lower_half, num)\n else\n upper_half = arr[(mid_idx + 1)..-1]\n bsearch(upper_half, num)\n end\n\nend",
"def binary_search(arr, element)\n low = 0\n high = arr.length - 1\n\n while low <= high\n mid = (low + high) / 2\n guess = arr[mid]\n\n if guess > element\n high = mid - 1\n elsif guess < element\n low = mid + 1\n else\n return mid\n end\n end\n\n nil\nend",
"def binary_search(binary, size, search_key, low, middle, high)\n while (low <= high)\n middle=(low+high)/2;\n print_row(binary, size, low, middle, high);\n if (search_key == binary[middle])\n return middle;\n elsif (search_key <= binary[middle])\n high=middle-1\n else \n low=middle+1\n end\n end\nend",
"def binary_search(array, length, value_to_find)\n mid_point = length/2\n mid = array[mid_point]\n counter = 0\n\n until mid == value_to_find || counter > length\n if mid > value_to_find\n mid_point = mid_point/2\n else \n mid_point = (length - mid_point)/2 + mid_point\n end\n\n mid = array[mid_point]\n counter += 1\n end\n\n mid == value_to_find\nend",
"def bsearch(array, target)\n # compare target value to middle element\n #if target value is == to middle elements value\n #return the position and end\n # if target value is less than middle value seach lower half of array\n # same goes for greater than (search upper half)\n # when it searches lower or upper half it keeps the same logic as the beginning\n # nil if not found; can't find anything in an empty array\n return nil if array.empty?\n\n index = array.length / 2\n # spaceship operator magic!\n case target <=> array[index]\n when -1 #search left side\n bsearch(array.take(index), target)\n when 0\n index\n when 1 #search right side\n answer = bsearch(array.drop(index + 1), target)\n answer.nil? ? nil : index + 1 + answer\n end\nend",
"def bsearch(arr, target)\n return nil if arr.empty?\n mid = arr.length / 2\n return mid if arr[mid] == target\n\n if target < arr[mid]\n bsearch(arr[0...mid], target)\n else\n result = bsearch(arr[mid + 1..-1], target)\n result.nil? ? nil : mid + 1 + result\n end\nend",
"def binary_search(array,target)\n \n min = 0\n max = array.length - 1\n \n while min <= max\n mid = (min + max) / 2\n if array[mid] > target\n max = mid -1\n elsif array[mid] < target\n low = mid + 1 \n else\n return mid\n end\n end\n\nend",
"def do_search(target_value, array)\n min = 0\n max = array.length - 1\n\n binary_search(target_value, array, min, max)\nend",
"def binary_search(array, target)\n return nil if array.length == 1 && array[0] != target\n mid = array.length / 2\n\n if target == array[mid]\n return mid\n elsif target < array[mid]\n return binary_search(array[0...mid], target)\n else\n found = binary_search(array[mid+1..-1], target)\n return found.nil? ? nil : mid + 1 + found\n end\nend",
"def binary_search(n, arr)\r\n middle = arr.length / 2 #finds the midpoint of the array\r\n i = 0\r\n j = arr.length - 1\r\n\r\n while i < j #while the array length is bigger than 0\r\n if arr[middle] == n #if the desired element (n) is the middle element, return true\r\n return true\r\n elsif arr[middle] < n #if the middle element is bigger than n\r\n i = middle + 1 #i becomes the element after the middle element\r\n middle = i + j / 2 #middle element becomes the middle of the higher-value elements on right of array \r\n else #if the middle element is not bigger than n, search the lower-value elements on left side of array\r\n j = middle - 1 #sets end of array to the element to the left of the middle\r\n middle = i + j / 2 #sets new middle as the middle of set of lower values (left half of array)\r\n end\r\n end\r\n false\r\nend",
"def binary_search(array, key)\n low, high = 0, array.length - 1\n while low <= high\n mid = (low + high) >> 1\n case key <=> array[mid] # if key < array[mid] then return -1 if key = array[mid] then 0 else return 1\n\t when 1\n low = mid + 1\n when -1\n high = mid - 1\n else\n return mid\n end\n end\nend",
"def binsearch(ary, x)\n left = 0\n right = ary.length - 1\n while left < right\n middle = (left + right) / 2\n Tanj.array :ary, index: [:left..:right, :middle]\n if ary[middle] == x\n Tanj.message \"found it!\"\n return middle\n elsif ary[middle] < x\n Tanj.message \"too small\"\n left = middle + 1\n elsif ary[middle] > x\n Tanj.message \"too large\"\n right = middle - 1\n else\n Tanj.message \"this should be unreachable!\"\n end\n end\n Tanj.message \"didn't find it\"\n return nil\nend",
"def bsearch(sorted_array, target)\n return nil if sorted_array.empty?\n \n i_mid = (sorted_array.length-1) / 2\n mid = sorted_array[i_mid]\n \n if target == mid\n i = i_mid\n elsif target < mid\n i = bsearch(sorted_array[0...i_mid], target)\n else\n i = bsearch(sorted_array[i_mid + 1..-1], target)\n i += mid + 1 if i\n end\n \n i\nend",
"def bsearch(array, target)\n return nil if !array.include?(target)\n arr = array.sort\n\n mid = arr.length / 2\n\n\n if arr[mid] == target\n return mid\n elsif arr[mid] < target\n mid + bsearch(arr[mid..-1], target)\n else\n bsearch(arr[0..mid-1], target)\n end\nend",
"def bsearch(arr, target)\n if arr.length == 1 \n if arr[0] == target\n return 0\n else\n return nil\n end\n end\n arr.sort!\n middle = arr.length / 2\n left = arr[0...middle]\n right = arr[middle + 1..-1]\n if arr[middle] == target\n return middle\n elsif arr[middle] < target\n if bsearch(right, target).nil?\n return nil\n # else\n return left.length + 1 + bsearch(right, target)\n end\n else \n bsearch(left, target)\n end\nend",
"def binary_search(arr, ele)\n min = 0;\n max = arr.size - 1;\n\n while min <= max \n \n middle = ( (min + max) / 2).floor\n \n if ele == arr[middle]\n return middle\n elsif ele < arr[middle]\n max = middle - 1\n elsif ele > arr[middle]\n min = middle + 1\n end\n\n end\n\n return -1 \nend",
"def recursive_bin_search(d, arr, first = 0, last=arr.size-1)\n middle = (first + last) / 2\n case arr[middle] <=> d\n when 0 # arr[middle] == d\n return true\n when -1 # arr[middle] < d\n first = first + 1\n return recursive_binary_search(arr, target, first, last)\n when 1 # arr[middle] > d\n last = last - 1\n return recursive_binary_search(arr, target, first, last)\n end\n end",
"def binary_search(target, collection, min_index = 0, max_index = collection.size - 1)\n return nil if collection.empty?\n loop do\n return nil if max_index < min_index\n index_to_check = mid_point(min_index, max_index)\n return index_to_check if collection[index_to_check] == target\n min_index = index_to_check + 1 if collection[index_to_check] < target\n max_index = index_to_check - 1 if collection[index_to_check] > target\n end\nend",
"def bsearch(arr,target)\r\n return nil if arr.length == 0 \r\n midIdx = arr.length/2\r\n mid = arr[midIdx] \r\n if mid > target #left half\r\n bsearch(arr[0...midIdx],target)\r\n elsif mid < target #right half\r\n\r\n idx = bsearch(arr[midIdx+1..-1],target)\r\n if idx \r\n idx + arr[0..midIdx].length\r\n else\r\n return nil\r\n end\r\n \r\n else\r\n return midIdx\r\n end\r\n\r\nend",
"def binary_search(array, value)\n return nil if array.length == 1 && array[0] != value\n midpoint = array.length/2\n return midpoint if array[midpoint] == value\n if array[midpoint] < value\n midpoint + binary_search(array[midpoint..array.length], value) if binary_search(array[midpoint..array.length], value)\n else\n binary_search(array[0...midpoint], value)\n end\nend",
"def bi_search(search_array, search_value, low = 0, high = nil)\n high ||= search_array.length - 1\n middle = ((low + high) / 2).ceil\n if low > high\n return -1\n elsif search_value == search_array[middle]\n return middle\n elsif search_value < search_array[middle]\n high = middle - 1\n elsif search_value > search_array[middle]\n low = middle + 1\n end\n bi_search(search_array, search_value, low = low, high = high)\nend",
"def bsearch(array, target)\n return nil if array.empty?\n\n n = array.size / 2\n bottom = array[0...n]\n mid = array[n]\n top = array[n + 1..-1]\n\n if target < mid\n bsearch(bottom, target)\n elsif target > mid\n top_search = bsearch(top, target)\n top_search.nil? ? nil : top_search + bottom.size + 1\n else\n mid == target ? n : nil\n end\nend",
"def binary_search(arr, target, idx_puls = 0)\n mid = arr.length / 2\n return mid + idx_puls if arr[mid] == target\n return nil if arr.length == 1\n\n if arr[mid] < target\n binary_search(arr[(mid + 1)..-1], target, mid + 1)\n else\n binary_search(arr[0...mid], target, idx_puls)\n end\n\nend",
"def bsearch arr, target \n return nil if arr.length == 1 && !arr.include?(target)\n\n mid_idx = arr.length / 2\n\n return mid_idx if arr[mid_idx] == target \n \n left = arr.take(mid_idx)\n right = arr.drop(mid_idx)\n\n if arr[mid_idx] > target \n bsearch(left, target)\n else \n result = bsearch(right,target)\n if result.nil? \n return nil \n else \n result + mid_idx\n end\n end\nend",
"def binary_search(array, value)\n low = 0\n high = array.length - 1\n\n while ( low <= high )\n mid = low + ( (high-low)/2 )\n\n if array[mid] == value\n return mid\n elsif array[mid] < value\n low = mid + 1\n else\n high = mid - 1\n end\n end\n\n return \"Value not found\"\nend",
"def binary_search(array, key, start_position)\n left = start_position\n right = array.size - 1\n\n while left < right\n mid = (left + right) / 2\n\n if array[mid] < key\n left = mid + 1\n else\n right = mid\n end\n end\n\n (left == right && array[left] == key) ? left : -1\nend",
"def bsearch(arr,target)\n# p arr\nreturn nil if arr.length==1 && target != arr[0]\nmid =arr.length/2 # 3,1,1,0\n# if arr.length==1 && arr[0] != target\n# return nil\n# end\n\n\nif target==arr[mid]\n\nreturn mid\nelsif target<arr[mid]\n left_index = 0\n right_index = mid-1\n return bsearch(arr[left_index..right_index],target)\n# return bsearch(arr.take(mid),target)\nelse\n left_index = mid+1\n right_index = arr.length-1\n sub_position=bsearch(arr[left_index..right_index],target)\n # sub_position=bsearch(arr.drop(mid+1),target)\n return sub_position.nil? ? nil : (mid+1)+sub_position \n\nend\nend",
"def binary_search(arr, target)\n binary_search_helper(arr, target, 0, arr.length - 1)\nend",
"def binsearch_index(low = nil, high = nil) \n return nil if length == 0\n low = 0 if !low\n high = length if !high\n\n if low == high\n if yield at(low)\n return low\n else\n return nil\n end\n end\n\n mid = (high-low)/2 + low\n if yield at(mid)\n # this value >= target.\n result = binsearch_index(low, mid == low ? mid : mid-1){ |x| yield x if !x.nil?}\n if result\n return result\n else\n return mid\n end\n else\n # this value < target\n binsearch_index(mid == high ? mid : mid+1, high){ |x| yield x if !x.nil?}\n end\n end",
"def binary_search(array, target)\n return nil if array.count == 0\n\n median = array.length / 2\n left = array[0...median]\n right = array[median + 1..-1]\n\n return median if array[median] == target\n if target < array[median]\n return binary_search(left, target)\n else\n sub_answer = binary_search(right, target)\n (sub_answer.nil?) ? nil : (sub_anser + median + 1)\n end\n\nend",
"def bsearch(array, value)\n return nil if array.empty?\n # return nil if !array.include?(value)\n\n # debugger\n indeces = array.dup.freeze #[1, 2, 3]\n \n middle = (array.length) / 2\n left = array[(0...middle)]\n right = array[(middle..-1)]\n\n # debugger\n if array[middle] == value\n return indeces.index(value) \n elsif value < array[middle]\n bsearch(left, value)\n else\n middle + bsearch(right, value)\n end\n #somewhere bsearch(array[(0..-2)]\nend",
"def bin_search_array(num, array)\n return \"not found!\" if array.nil? || array.empty?\n mid = (array.length / 2).ceil\n puts mid\n if array[mid] == num\n puts \"found!\"\n return mid\n elsif array[mid] > num\n puts \"searching left in #{array[0..mid]}\"\n bin_search_array(num, array[0..mid])\n else\n puts \"searching right in #{array[mid...array.length]}\"\n bin_search_array(num, array[mid...array.length])\n end\nend",
"def binary_search(array, length, value_to_find)\n raise NotImplementedError\nend",
"def binary_search(arr,tar)\n return nil if arr.length < 1\n mid_idx = arr.length / 2\n if arr[mid_idx] == tar\n return mid_idx\n elsif arr[mid_idx] > tar\n binary_search(arr[0...mid_idx],tar)\n elsif arr[mid_idx] < tar\n subanswer = binary_search(arr[mid_idx+1..-1],tar)\n subanswer.nil? ? nil : (mid_idx+1) + subanswer\n end\nend",
"def binary_search(arr, target)\n if arr.length == 1\n return nil if arr[0] != target\n end\n mid = arr.length / 2\n if target == arr[mid]\n return mid\n elsif target > arr[mid]\n if binary_search(arr[mid..arr.length], target) == nil\n return nil\n else\n return binary_search(arr[mid..arr.length], target) + arr.length / 2\n end\n else\n binary_search(arr[0..mid-1], target)\n end\nend",
"def bsearch(array, target)\n return nil if array.empty?\n\n mid_idx = array.length / 2\n mid_ele = array[mid_idx]\n\n return mid_idx if target == mid_ele\n\n if target < mid_ele\n sub_arr = array[0...mid_idx]\n return bsearch(sub_arr, target)\n else\n sub_arr = array[mid_idx + 1..-1]\n next_search = bsearch(sub_arr, target)\n return nil if next_search == nil\n return mid_idx + 1 + next_search\n end\nend",
"def binary_search(array, target) \n return nil if array.length == 0\n mid = array.length / 2\n return mid if array[mid] == target\n left = array[0...mid]\n right = array[mid + 1..-1]\n if array[mid] > target #[]\n binary_search(left, target)\n else\n result = binary_search(right, target)\n return result.nil? ? nil : result + mid + 1\n end\n \nend",
"def search_insert_log(nums, target)\n left = 0\n right = nums.length - 1\n\n while left <= right\n mid = left + ((right - left) / 2)\n\n return mid if nums[mid] == target\n\n if target > nums[mid]\n left = mid + 1\n else\n right = mid - 1\n end\n end\n left\nend",
"def binary_search(array, target)\n return nil if array.empty?\n\n middle_idx = array.length/2\n\n case target <=> array[middle_idx]\n\n when -1\n binary_search(array.take(middle_idx), target)\n when 0\n return middle_idx\n when 1\n binary_search(array[middle_idx..-1], target)\n end\n\nend",
"def binary_search(array, length, value_to_find)\n if length == 0\n return false\n end\n low_point = 0\n high_point = length - 1\n while low_point < high_point\n mid = (low_point + high_point) / 2\n if array[mid.floor] == value_to_find\n return true\n elsif array[mid.floor] > value_to_find\n high_point = mid - 1\n else\n low_point = mid + 1\n end\n end\n #After the while low_point < high_point, there is a case where low_point is equal to high_point and we need an additional if statement below to check whether the value at highpoint -lowpoint and hightpoint are the same index at this point) is equal to the value_to_find\n if array[low_point] == value_to_find\n return true\n else\n return false\n end\nend",
"def b_search(arr, target)\n return false if arr.empty?\n mid = arr / 2\n if arr[mid] == target\n true\n elsif arr[mid] < target\n b_search(arr[mid..-1], target)\n else\n b_search(arr[0...mid], target)\n end\nend",
"def binary_search(arr, target)\n new_arr = arr\n return nil if arr.empty? \n middle = (arr.length - 1) / 2\n if arr[middle] > target\n binary_search(arr[0...middle], target)\n elsif arr[middle] < target \n if binary_search(arr[middle+1..-1], target).nil?\n return nil\n else\n binary_search(arr[middle+1..-1], target) + middle + 1\n end \n elsif target == arr[middle]\n return new_arr.index(arr[middle])\n else\n return nil\n end\nend",
"def binary_search(array, find)\n\tlow = 0\n\thi = array.length-1 \n\n\twhile (low <= hi)\n\t\tmid = low + (hi-low)/2\n\n\t\tif array[mid] == find\n\t\t\treturn mid\n\t\telsif array[mid] < find\n\t\t\tlow = mid + 1\n\t\telse \n\t\t\thi = mid - 1\n\t\tend\t\n\tend\n\n\treturn \"Value not found in array\"\n\nend",
"def binary_search(arr, val, strategy='rec')\n if strategy != 'rec'\n search(arr, val)\n else\n rec_search(arr, val, 0, arr.size - 1)\n end\nend",
"def binary_search_integers(sorted_array, value)\n low = 0\n high = sorted_array.length - 1\n\n while low <= high\n mid = (low + high)/2\n guess = sorted_array[mid]\n\n if guess == value\n return mid\n end\n\n if guess > value\n high = mid - 1\n else\n low = mid + 1\n end\n end\n return nil\nend",
"def binary_search(array, element, low=0, high=array.length-1)\n return nil if high < low\n\n mid = ( low + high ) / 2\n\n if array[mid] > element\n return binary_search(array, element, low, mid - 1)\n elsif array[mid] < element\n return binary_search(array, element, mid + 1, high)\n else\n return mid\n end\nend",
"def binary_search_recursive(array, target, low = 0, high = array.length - 1)\n return \"#{target} value could not be found\" if low > high\n mid = (low + high) / 2\n return mid if array[mid] == target\n p \"#{low} #{mid} #{high}\"\n if array[mid] > target\n high = mid - 1\n else\n low = mid + 1\n end\n binary_search_recursive(array, target, low, high)\nend",
"def sorted_binary_search(arr, key)\n least = 0\n high = arr.length - 1\n\n while(least <= high)\n mid = least + ((high-least)/2)\n puts \"arr: #{arr[mid]} mid: #{mid} least: #{least} high: #{high}\"\n if arr[mid] == key\n return mid\n elsif arr[mid] < key\n least = mid + 1\n else\n high = mid - 1\n end\n end\n return \"The value is not there\"\nend",
"def recursive_binary_search_two(arr, value)\n low, hi = get_limits(arr)\n return false if low >= hi\n\n mid = (low + hi) / 2\n if arr[mid] == value\n true\n elsif arr[mid] < value\n recursive_binary_search_two(arr[mid + 1..hi], value)\n else\n recursive_binary_search_two(arr[low..mid], value)\n end\nend",
"def bsearch(nums, target)\n return nil if nums.empty?\n\n probe_index = nums.length / 2\n case target <=> nums[probe_index]\n when -1\n bsearch(nums.take(probe_index), target)\n when 0\n probe_index\n when 1\n\n sub_answer = bsearch(nums.drop(probe_index + 1), target)\n (sub_answer.nil?) ? nil : (probe_index + 1) + sub_answer\n end\n\nend",
"def binarysearch(v, key)\n\tlow = 0\n\thigh = v.length - 1\n\twhile low <= high\n\t\tmid = (low + high) / 2\n\t\t#was having trouble with if/else so went with case statement\n\t\tcase\n\t\t\twhen (v[mid] < key) \n low = mid + 1\n\t\t\twhen (v[mid] > key) \n\t\t\t\thigh = mid - 1\n\t\t\telse \n\t\t\t\treturn mid\n\t\tend\n\tend\n\t-1\t#if key not found\nend",
"def binary_search(array, length, value_to_find)\n beg_index = 0\n end_index = length - 1\n while beg_index <= end_index do\n half = (end_index - beg_index) / 2\n if array[beg_index + half] == value_to_find\n return true\n elsif array[beg_index + half] < value_to_find\n beg_index = beg_index + half + 1\n else\n end_index = beg_index + half - 1\n end\n end\n return false\nend",
"def search(a, x) # search for x in a[]\n puts \"Called search(#{a.inspect}, #{x})\"\n return false if a.length == 0\n\n mid = a.length / 2\n left, right = 0, -1\n if a[mid] == x\n true\n elsif a[mid] <= a[right] # sorted, between mid -> right\n if x > a[mid] && x <= a[right]\n search(a.right, x)\n else\n search(a.left, x)\n end\n else # resets after middle\n if x > a[mid] || x <= a[right]\n search(a.right, x)\n else\n search(a.left, x)\n end\n end\nend",
"def binary_search(arr, target)\n mid = arr.length / 2\n left = arr.slice(0, mid)\n right = arr.slice(mid, arr.length)\n if arr.length < 2\n return arr.first == target\n elsif left.last >= target\n return binary_search(left, target)\n elsif right.last >= target\n return binary_search(right, target)\n else\n false\n end\nend",
"def binary_search(array, value)\n low = 0\n high = array.length - 1\n\n while (low <= high)\n mid = low + ( (high-low) / 2 )\n\n if array[mid] == value\n return mid\n elsif array[mid] < value\n low = mid + 1\n else\n high = mid - 1\n end\n end\n\n return \"Value not found in given array\"\nend",
"def binary_search(array, target)\n return nil if array.empty?\n midpoint = array.length / 2\n case target <=> array[midpoint]\n when 0\n midpoint\n when 1\n right_idx = binary_search(array[(midpoint + 1)..-1], target)\n if right_idx\n right_idx + 1 + midpoint\n else\n nil\n end\n when -1\n binary_search(array[0...midpoint], target)\n end\nend",
"def bsearch(a,s,m,n)\n\n\tmiddle=(m+n)/2\n\n\tif n<=m then\n\treturn (s > a[m])? (m + 1): m\n\t\n\n\telsif s==a[middle] \n\treturn middle+1\n\n\telsif s>a[middle] \n\treturn bsearch(a,s,middle+1,n)\n\t\t\n\t\n\telse\n\treturn bsearch(a,s,m,middle-1)\n\t\n\tend\n\tend",
"def binary_search(array, target)\n mid = array.length / 2\n\n if target < array[mid]\n binary_search(array[0...mid], target)\n elsif value > array[mid]\n function = binary_search(array[mid + 1..-1], target)\n function.nil? ? nil : function + mid + 1\n else\n return mid\n end\nend",
"def bsearch(arr, target)\n i = 0\n j = arr.length - 1\n while i <= j\n m = (i + j) / 2\n if target < arr[m]\n j = m - 1\n elsif target > arr[m]\n i = m + 1\n elsif target == arr[m]\n return m\n end\n end\n -1\nend",
"def binary_search(a, item, start_i=0, end_i=a.size-1)\n\tif start_i >= end_i\n\t\treturn nil\n\tend\n\tmid = (start_i + end_i) / 2\n\tif item < a[mid]\n\t\treturn binary_search(a, item, start_i, mid-1)\n\telsif item > a[mid]\n\t\treturn binary_search(a, item, mid+1, end_i)\n\telse\n\t\treturn item\n\tend\nend",
"def bsearch(arr, target)\r\n return false if arr.length == 0\r\n\r\n mid = arr.length/2\r\n\r\n return mid if arr[mid] == target\r\n if arr[mid] > target\r\n found = bsearch(arr[mid+1..-1], target)\r\n found + mid + 1 unless found == false\r\n else\r\n bsearch(arr[0...mid], target)\r\n end\r\n false\r\nend",
"def bsearch(arr, target)\n return nil if arr.length == 0\n mid = arr.length/2\n\n if target < mid\n bsearch(arr.take(mid), target)\n elsif target == arr[mid]\n return true\n else\n search_res = bsearch(arr.drop(mid + 1), target)\n search_res.nil? ? false : true\n end\nend",
"def binary_search(target, array)\n length = array.length\n center = length / 2\n first = 0\n last = length - 1\n\n while first <= last\n if array[center] == target\n return array.index(target)\n elsif array[center] < target\n first = center + 1\n center = (first + last) / 2\n else\n last = center - 1\n center = (first + last) / 2\n end\n end\n\n return -1\nend",
"def binary_search(array, value)\n \n # First, we establish the lower and upper bounds of where the value we are\n # searching for can be. At the beginning, the lower bound is the first value\n # of the array and the upper bound is the last value of the array.\n lower_bound = 0\n upper_bound = array.length - 1\n\n # Now we start searching for the value inside the array between the lower and upper bounds.\n # In each iteration of the loop, we check the middle value between the lower and upper bounds\n # against the value we are searching for. If the middle value matches the value we are searching\n # for then we stop, otherwise we update the lower and upper bounds of our search accordingly(Should\n # we search to the right or the left of the mid point in the next iteration to find the value we are\n # looking for).\n #\n # If the value at the mid point matches with the value we are looking for, we are done and we return\n # the mid point(index of the value we are looking for).\n #\n # If the value is lower than the value at the mid point, we should to search to the left side of the mid point\n # in the next iteration. So we set the upper bound to the left of mid point.\n #\n # If the value is higher than the value at the mid point, we should to search to the right side of the mid point\n # in the next iteration. So we set the lower bound to the right of mid point.\n\n while lower_bound <= upper_bound\n\n # Find the mid point between the upper and lower bounds\n mid_point = (lower_bound + upper_bound) / 2\n\n # Look up the value at the mid point\n value_at_mid_point = array[mid_point]\n\n # Check the value at the mid point against the value we are looking for:\n\n if value == value_at_mid_point\n return mid_point\n elsif value < value_at_mid_point\n upper_bound = mid_point - 1\n elsif value > value_at_mid_point\n lower_bound = mid_point + 1\n end\n end\n\n # If the value is not found, return nil indicating the value we are searching for\n # doesn't exist inside the array.\n return nil\nend",
"def bsearch(array, target)\n return nil if array.length == 1 && target != array[0]\n idx = array.length / 2\n mid_ele = array[idx]\n\n if target == mid_ele\n return idx\n elsif target < mid_ele\n return bsearch(array[0...idx], target)\n else\n if bsearch(array[idx+1..-1], target).nil?\n return nil\n else\n return idx + 1 + bsearch(array[idx+1..-1], target)\n end\n end\nend"
] |
[
"0.76373416",
"0.7475979",
"0.7399161",
"0.73615175",
"0.7347026",
"0.7314209",
"0.73073804",
"0.7297506",
"0.72946084",
"0.72779703",
"0.72716993",
"0.72714156",
"0.7270871",
"0.7267975",
"0.7247053",
"0.7227337",
"0.722029",
"0.7203278",
"0.7189277",
"0.71764624",
"0.7173953",
"0.7170113",
"0.71701086",
"0.71663755",
"0.71630776",
"0.7148388",
"0.7146541",
"0.7141581",
"0.71352035",
"0.7129512",
"0.7129512",
"0.71283126",
"0.7112243",
"0.70986575",
"0.7098436",
"0.7089519",
"0.708725",
"0.707873",
"0.7075548",
"0.70688003",
"0.70523566",
"0.70484287",
"0.70464873",
"0.704538",
"0.7038591",
"0.7035229",
"0.70286626",
"0.7024942",
"0.70206124",
"0.7017089",
"0.7013502",
"0.7011766",
"0.70114416",
"0.69994354",
"0.6998297",
"0.6997182",
"0.699232",
"0.699177",
"0.6980333",
"0.6975558",
"0.6968103",
"0.6966195",
"0.69632417",
"0.69578755",
"0.6957213",
"0.694907",
"0.6948872",
"0.6948751",
"0.69459873",
"0.6940456",
"0.69404554",
"0.69392824",
"0.69314843",
"0.6931308",
"0.69307554",
"0.6929597",
"0.6927024",
"0.6920398",
"0.69203776",
"0.69202435",
"0.69127846",
"0.69125503",
"0.69087476",
"0.6907792",
"0.6902832",
"0.68994415",
"0.689261",
"0.68917793",
"0.68913054",
"0.68847674",
"0.68758607",
"0.68731433",
"0.6870611",
"0.6868129",
"0.6866996",
"0.68650764",
"0.6856975",
"0.6856238",
"0.68555325",
"0.6853834",
"0.68440926"
] |
0.0
|
-1
|
Show's the enumeration's configured +Show+ view, as defined in streamlined_ui and Streamlined::Column.
|
def show_enumeration
self.instance = model.find(params[:id])
rel_type = model_ui.scalars[params[:enumeration].to_sym]
render(:file => rel_type.show_view.partial, :use_full_path => false,
:locals => {:item => instance, :relationship => rel_type})
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def show(value)\n @ole.Show = value\n nil\n end",
"def show\n default_semantic_show\n end",
"def set_show(val)\n self.show = val\n self\n end",
"def override_show_column_ui(list_ui)\r\n \"active_scaffold_show_#{list_ui}\"\r\n end",
"def show\n self.visible = true\n end",
"def show\n IRuby.display(self)\n end",
"def show\n @visible = true\n self\n end",
"def show\n \n end",
"def show\n \n end",
"def show\n \n end",
"def show\n \n end",
"def show\n \n end",
"def show\n \n end",
"def show\n \n end",
"def show\n \n end",
"def show\n \n end",
"def show!\n visible(true)\n end",
"def show!\n visible(true)\n end",
"def display\n to_h.fetch(:display)\n end",
"def display\n to_h.fetch(:display)\n end",
"def do_show\n super\n display_columns = ShowColumns\n display_columns -= ModeratorOnlyColumns unless can_edit_member(@record, current_user)\n active_scaffold_config.show.columns = display_columns\n end",
"def begin_view_show(object_locale_key)\n begin_view(t(:Show),\" \",t(object_locale_key))\n end",
"def show\n # logger.debug2 \"Giftshow: show = #{read_attribute(:show)} (#{read_attribute(:show).class.name})\"\n return nil unless (extended_show = read_attribute(:show))\n encrypt_remove_pre_and_postfix(extended_show, 'show', 30)\n end",
"def render_simple_show(instance, options = {})\n options.symbolize_keys!\n options[:exclude] ||= []\n options[:ignored_foreign_keys] ||= []\n if options[:prefix]\n options[:prefix] += '_'\n else\n options[:prefix] = ''\n end\n instance.class.columns.each do |c|\n next if options[:exclude].include? c.name.to_sym\n haml_tag :p do\n haml_tag :label, {:for => c.name} do\n haml_concat h(c.name.humanize)\n end\n if ((c.name.split('_')[-1] == 'id' && c.name != 'id') && (!options[:ignored_foreign_keys].include?(c.name.to_sym)))\n # handle foreign key fields\n foreign_model = (options[:prefix].to_s + c.name.gsub(/_id$/, '')).camelize.constantize\n if foreign_model.columns.include?('name')\n haml_concat h(instance.__send__(foreign_model.to_s.underscore).name)\n elsif foreign_model.columns.include?('description')\n haml_concat h(instance.__send__(foreign_model.to_s.underscore).description)\n else\n haml_concat h(instance.__send__(c.name))\n end\n else\n haml_concat h(instance.__send__(c.name))\n end\n haml_tag :br\n end\n end\n haml_tag :span\n end",
"def show() end",
"def show() end",
"def show() end",
"def show_style\n :short\n end",
"def show(show)\n dsl_data[:show] = show\n end",
"def show\n @ole.Show\n end",
"def display\n @attributes[:display]\n end",
"def show\n closed!\n if @debug\n ary = @leds.map { |value| Rainbow(@debug).color(*to_rgb(value)) }\n $stdout.print \"\\r#{ary.join}\"\n end\n self\n end",
"def display_values\n options.each do |option|\n update_ui option, read(option)\n end\n end",
"def show ; end",
"def show \r\n end",
"def show(text,align={ :align=> :show_left })\n set RGhost::Show.new(text.to_s,align) \n end",
"def display_show_interface\n Show.display_all_shows_lite\n puts \"There are #{Show.all.size} shows. Enter the number of the show you'd like to display\"\n usr_input = get_usr_input.to_i\n if usr_input <= Show.all.size\n disp_horiz_line\n Show.display_show(usr_input)\n disp_horiz_line\n end\n end",
"def show\n Frame.new.tap {|f| f.add(self) }.show\n end",
"def show(screen)\n\n screen.set_pos_by_point(Point.zeroPoint)\n\n if @selected\n screen.attron(A_REVERSE)\n else\n screen.attron(A_UNDERLINE)\n end\n\n @menu_items.each do |menu_item|\n screen.addstr( \"#{menu_item} \")\n end\n\n p = screen.cur_point\n\n screen.addstr( ' ' * (screen.width - p.x) )\n\n if @selected\n screen.attroff(A_REVERSE)\n else\n screen.attroff(A_UNDERLINE)\n end\n\n end",
"def select_option_display\n display_value = self.name + \" [v.#{self.snapshot}]\"\n display_value += self.synopsis.present? ? \" (#{self.synopsis})\" : \"\"\n display_value\n end",
"def show\n\t\t end",
"def show\n run List::Show\n render cell(List::Cell::Show, result['model']), layout: true\n end",
"def show\n raise NotImplementedError\n end",
"def show\n\t puts \"\t#{@spaces[0]} #{@spaces[1]} #{@spaces[2]}\"\n\t puts \"\t#{@spaces[3]} #{@spaces[4]} #{@spaces[5]}\"\n\t puts \"\t#{@spaces[6]} #{@spaces[7]} #{@spaces[8]}\"\n\tend",
"def display_as=(value)\n @display_as = value\n end",
"def show(*values)\n values.inject(self) { |res, val| res._show(val) or fail ArgumentError, \"Unknown value for show: #{val}\" }\n end",
"def show(*values)\n values.inject(self) { |res, val| res._show(val) or fail ArgumentError, \"Unknown value for show: #{val}\" }\n end",
"def show(*values)\n values.inject(self) { |res, val| res._show(val) or fail ArgumentError, \"Unknown value for show: #{val}\" }\n end",
"def show(*values)\n values.inject(self) { |res, val| res._show(val) or fail ArgumentError, \"Unknown value for show: #{val}\" }\n end",
"def show(*values)\n values.inject(self) { |res, val| res._show(val) or fail ArgumentError, \"Unknown value for show: #{val}\" }\n end",
"def show\n #not needed for our implementation\n end",
"def show\n puts \"******* show *******\"\n end",
"def show_as(*args, &proc) # :yields: field_def or nil\n @view_control.show_as(*args, &proc)\n end",
"def show\n view_options(\n full_width: true,\n small_footer: @game.uses_small_footer? || enable_scrolling?,\n has_i18n: @game.has_i18n?\n )\n end",
"def display(line, column=0)\n result = \"\\e[s\"\n result << \"\\e[#{line.to_i};#{column.to_i}H\"\n result << to_s\n result << \"\\e[u\"\n result\n end",
"def show_control(**opt)\n icon_control(:show, **opt)\n end",
"def show; @showing = false; end",
"def show\n \n \n end",
"def show\n @cursor.call(0)\n @visible=true\n end",
"def show\n style[:hidden] = false\n update_visibility\n end",
"def show\n set_cell\n end",
"def show_column_list( enum, subheading )\n\t\tpr = self.prompt\n\t\titems = nil\n\n\t\tif enum.first.respond_to?( :name )\n\t\t\titems = enum.map( &:name ).map( &:to_s ).uniq\n\t\telse\n\t\t\titems = enum.map( &:oid ).uniq\n\t\tend\n\n\t\tpr.say( \"\\n\" )\n\t\tpr.say( pr.color(subheading, :subheader) )\n\t\tpr.say( pr.list(items.sort_by(&:downcase), :columns_down) )\n\tend",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end",
"def show; end"
] |
[
"0.65104926",
"0.63655216",
"0.6319261",
"0.618467",
"0.612976",
"0.60494447",
"0.60416734",
"0.5959447",
"0.5959447",
"0.5959447",
"0.5959447",
"0.5959447",
"0.5959447",
"0.5959447",
"0.5959447",
"0.5959447",
"0.58757544",
"0.58757544",
"0.5873129",
"0.5873129",
"0.58160776",
"0.57341486",
"0.57123876",
"0.5708643",
"0.57030624",
"0.57030624",
"0.57030624",
"0.56791776",
"0.56789076",
"0.564673",
"0.5613887",
"0.560863",
"0.5585693",
"0.55798054",
"0.5579481",
"0.55623525",
"0.55518514",
"0.55489886",
"0.5516275",
"0.548389",
"0.5461805",
"0.5451642",
"0.54484594",
"0.5444937",
"0.5420655",
"0.5407016",
"0.5407016",
"0.5407016",
"0.5407016",
"0.5407016",
"0.5391497",
"0.53828084",
"0.536827",
"0.5358155",
"0.5348328",
"0.5346867",
"0.5339359",
"0.53392595",
"0.5335811",
"0.5333809",
"0.5327406",
"0.53248096",
"0.53210133",
"0.5320832",
"0.5320832",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052",
"0.5319052"
] |
0.5883871
|
16
|
Select an item in the given enumeration. Used by the enumerable view, as defined in Streamlined::Column.
|
def update_enumeration
self.instance = model.find(params[:id])
item = (params[:item] == 'nil') ? nil : params[:item]
instance.update_attribute(params[:rel_name], item)
render(:nothing => true)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def choice(indx)\n items[to_display.options[:choices][indx]]\n end",
"def select_item\n @selected = @current\n\n items\n end",
"def select_by_index(input)\r\n raise \"Index must be 0 or greater\" if input < 0\r\n begin\r\n expand_combo\r\n list_items[input].select\r\n ensure\r\n collapse_combo\r\n end\r\n end",
"def select_item(what)\n item = find_item(what)\n item.click if item\n end",
"def select( item )\r\n select_item_in_select_list(:text, item)\r\n end",
"def select_for_item(item)\n @cursor_fix = item.for_user?\n @cursor_all = item.for_all?\n if @cursor_fix\n select($game_party.menu_actor.index)\n elsif @cursor_all\n select(0)\n else\n select_last\n end\n end",
"def select_value( item )\r\n select_item_in_select_list( :value , item )\r\n end",
"def select_with_index(val)\n option_locator = \"index=#{val}\"\n @driver.sc_select(:view, option_locator, self.abs_path)\n stall :select\n end",
"def select(input)\r\n case input\r\n when String then select_by_name(input)\r\n when Integer then select_by_index(input)\r\n else raise ArgumentError, \"Select by name or by index\"\r\n end\r\n end",
"def select\r\n assert_exists\r\n if(@how == :text)\r\n @select_list.select(@what)\r\n elsif(@how == :value)\r\n @select_list.select_value(@what)\r\n end \r\n end",
"def get_selected_item\n @items[@selected_slot]\n end",
"def selected\r\n #TODO: find a way to not need to expand and collapse before getting the selected item\r\n expand_combo\r\n collapse_combo\r\n #get_selection.first\r\n get_selection.first\r\n end",
"def select(val)\n raise \"select requires a String.\" unless val.is_a? String\n @select = val\n self\n end",
"def selecting(&blk)\n Enumerator.new do |yielder|\n each do |*item|\n yielder.yield *item if blk.call(*item)\n end\n end\n end",
"def selected_item\n return (self.index < 0 ? nil : @data[self.index])\n end",
"def selected_item\n return (self.index < 0 ? nil : @data[self.index])\n end",
"def selected_item\n return (self.index < 0 ? nil : @data[self.index])\n end",
"def select_col(col)\n select(col).all.map { |row| row[col]}\n end",
"def user_select(items)\n choose do |menu|\n menu.index = :number\n menu.prompt = \"Please Choose One:\"\n menu.select_by = :index_or_name\n items.each do |item|\n menu.choice item.to_sym do |command| \n say \"Using: #{command}\" \n selected = command.to_s\n end\n end\n menu.choice :exit do exit 1 end\n end\n end",
"def select_by_name(input)\r\n begin\r\n expand_combo\r\n my_item = list_items.find {|item| item.name == input}\r\n raise Bewildr::NoSuchItemInComboBox if my_item.nil?\r\n my_item.select\r\n ensure\r\n collapse_combo\r\n end\r\n end",
"def selection *params\n opt = parse_params_for_select params\n return @adapter.selection(opt)\n end",
"def select(&block)\n scope.select(*build_attributes(true, &block))\n end",
"def user_select(items)\n h.choose do |menu|\n menu.index = :number\n menu.prompt = 'Please Choose One:'\n menu.select_by = :index_or_name\n items.each do |item|\n menu.choice item.to_sym do |command|\n ui.msg \"Using: #{command}\"\n selected = command.to_s\n end\n end\n menu.choice :all do return :all end\n menu.choice :exit do exit 1 end\n end\n end",
"def select\n self[:select]\n end",
"def selected_item\n get_content()[focussed_index()]\n end",
"def selected_item\n get_content()[focussed_index()]\n end",
"def select; end",
"def select; end",
"def taskforce_select(enum, &block)\n Enumerator.new do |current_value| # this default serves as the new generator for the enum generator to processed\n enum.each do|value| # this iterates careful through enum passed \n current_value.yield value if block.call(value) #only provide a value if its within check by code blocks\n end\n end\n end",
"def select\n self[:select]\n end",
"def select_by(how, what); end",
"def selected_item\n # @list[@current_index]\n end",
"def find_item(selected_item)\n return find(selected_item)\n end",
"def select(mailbox)\n tagged_response(\"SELECT\", to_utf7(mailbox))\n end",
"def select\n cached_fetch(:select){default_select}\n end",
"def select_by(key, value)\n option = Selenium::WebDriver::Support::Select.new(element)\n option.select_by(key, value)\n end",
"def select locator, option_locator\r\n command 'select', locator, option_locator\r\n end",
"def select locator, option_locator\r\n command 'select', locator, option_locator\r\n end",
"def selectItem(item, offset)\n Draw.writeChtypeAttrib(@pull_win[@current_title], 1,\n item + CDK::MENU::TITLELINES - offset,\n @sublist[@current_title][item], @subtitle_attr,\n CDK::HORIZONTAL, 0, @sublist_len[@current_title][item])\n end",
"def [](choice)\n choices[choice]\n end",
"def test_selectItem\n\t\t#vm = VendingMachine.new\n\t\tvm = VendingMachine.new(@db)\n\t\tvm.output = StringIO.new\n\t\t# vm.items[\"A1\"].quantity = 1\n\t\tvm.inputMoney(0.50)\n\t\titem = vm.selectItem(\"A1\")\n\t\tassert_not_nil(item)\n\t\tassert_equal(\"A1\", item.code)\n\t\tassert_equal(\"Almond Joy\", item.description)\n\tend",
"def get\n sel = self.selected\n if sel.length == 1\n sel.first\n else\n sel\n end\n end",
"def select\n execute_only(:select)\n end",
"def select_for_level(level, iter, mc, model)\n raise\n end",
"def each(&block)\n return to_enum unless block_given?\n\n @selected.each(&block)\n end",
"def draw_enum(col, enum)\n _draw_head(col){\n @vc.draw_enum(@f, col, enum,\n :choice_1st => ['(all)',''],\n :class => @record._klass_str.constantize\n )\n }\n end",
"def selected_actor(i=nil)\n actor = nil\n if i == nil\n actor = @data[self.index]\n else\n actor = (index < 0 || self.index(i) < 0 ? nil : @data[self.index(i)])\n end\n return actor\n end",
"def selected_actor(i=nil)\n actor = nil\n if i == nil\n actor = @data[self.index]\n else\n actor = (index < 0 || self.index(i) < 0 ? nil : @data[self.index(i)])\n end\n return actor\n end",
"def my_select\n return to_enum unless block_given?\n\n selected = []\n my_each { |i| selected << i if yield(i) }\n selected\n end",
"def get_enum(col)\n @vc.get_enum(@f.object.class, col)\n end",
"def select(option)\n locator = \"#{@locator}//li[text()='#{option}']\"\n DwrElement.new(locator).click\n end",
"def select_item_by_index(webelement,index)\n option=Selenium::WebDriver::Support::Select.new(@driver.find_element(webelement))\n option.select_by(:index,index)\n end",
"def select_with_value(val)\n guid = @driver.get_sc_guid(val)\n option_locator = \"value=regexi:^#{guid}$\"\n @driver.sc_select(:view, option_locator, self.abs_path)\n stall :select\n end",
"def select_menu_item app, *path\n app.application.select_menu_item *path\n end",
"def selected; end",
"def [](name)\n name = dasherize(name)\n name.downcase!\n selected = select_field_for(name)\n case\n when selected.length > 1\n selected.map { |f| f }\n when !Utilities.blank?(selected)\n selected.first\n else\n nil\n end\n end",
"def select(*) end",
"def selected_value\n @keys ? @keys[self.index] : self.index\n end",
"def select_item_by_value(webelement,value)\n option=Selenium::WebDriver::Support::Select.new(@driver.find_element(webelement))\n option.select_by(:value,value)\n end",
"def select_item_from_list(by, value, option_text)\n items = @browser.find_elements(by, value).first\n items.find_elements(tag_name: 'option').find do |option|\n option.text == option_text\n end.click\n end",
"def select(*a)\n page.select selector_for(*a)\n end",
"def select(&block)\n @select = block if block\n @select\n end",
"def selection\n eval_param(:selection)\n end",
"def selection_from(index)\n execute_only(:selection, :from, index)\n end",
"def select_item_in_select_list(attribute, value)\r\n assert_exists\r\n highlight( :set )\r\n doBreak = false\r\n #element.log \"Setting box #{@o.name} to #{attribute} #{value} \"\r\n @o.each do |option| # items in the list\r\n if value.matches( option.invoke(attribute.to_s))\r\n if option.selected\r\n doBreak = true\r\n break\r\n else\r\n option.selected = true\r\n @o.fireEvent(\"onChange\")\r\n @o.wait\r\n doBreak = true\r\n break\r\n end\r\n end\r\n end\r\n unless doBreak\r\n raise NoValueFoundException, \r\n \"No option with #{attribute.to_s} of #{value} in this select element\" \r\n end\r\n highlight( :clear )\r\n end",
"def select_by_id(type, id)\n result = nil\n\n case type \n when \"channel\"\n result = @channels.index { |channel| channel.id == id }\n raise ArgumentError, \"no channel with id: #{id}\" if result.nil?\n @selected = @channels[result]\n when \"user\"\n result = @users.index { |user| user.id == id }\n raise ArgumentError, \"no user with id: #{id}\" if result.nil?\n @selected = @users[result]\n end\n end",
"def [](sel); end",
"def selected=(value)\n return if value == @selected\n if value\n move(*SELECT_POSITION_OFFSET)\n @icon.select(1, @real_index)\n @icon.angle = ANGLE_VARIATION\n else\n move(-SELECT_POSITION_OFFSET.first, -SELECT_POSITION_OFFSET.last)\n @icon.select(0, @real_index)\n @icon.angle = 0\n end\n @selected = value\n @counter = 0\n end",
"def infinite_select(enum, &block)\n Enumerator.new do |yielder|\n enum.each do |value|\n if block.call(value) then yielder.yield value else break end\n end\n end\nend",
"def select(&block)\n @_componentable_container.select(&block)\n end",
"def sub_select _value=0\n send_cmd(\"sub_select #{_value}\")\n end",
"def select(how, what)\n case how\n when :text, :index, :value\n raise NotImplementedError\n else\n raise ArgumentError, \"can't select options by #{how.inspect}\"\n end\n end",
"def get_enum(col)\n @vc.get_enum(@record._klass_str.constantize, col)\n end",
"def select(option)\n locator = \"#{@locator}//li/a[text()='#{option}'] | #{@locator}//span[text()='#{option}']\"\n DwrElement.new(locator).click\n end",
"def selected_value\n return @keys ? @keys[self.index] : self.index\n end",
"def select(*args)\n dataset.select(*args)\n end",
"def select(_if, _then, _else, name = \"\")\n Instruction.from_ptr(C.build_select(self, _if, _then, _else, name))\n end",
"def get_selection\n begin\n @info.get('sel.first', 'sel.last')\n rescue\n ''\n end\n end",
"def select_marital_option(marital_status)\n # Consider something like a case statement and check the selenium selected? method\n case marital_status.downcase\n when 'single'\n @chrome_driver.find_elements(:name, MARITAL_STATUS)[0].click\n when 'married'\n @chrome_driver.find_elements(:name, MARITAL_STATUS)[1].click\n when 'divorced'\n @chrome_driver.find_elements(:name, MARITAL_STATUS)[2].click\n end\n end",
"def selection_element(element = None)\n execute(:selection, :element, element)\n end",
"def select(scope) # abstract\n end",
"def selection_to(index)\n execute(:selection, :to, index)\n end",
"def request_item(options = Hash.new,&block)\n items = options[:items] || []\n case items.size\n when 0 then block_given? ? raise(SystemExit) : nil\n when 1 then block_given? ? yield(items[0]) : items[0]\n else\n _options = default_options_for_cocoa_dialog(options)\n _options[\"title\"] = options[:title] || \"Select item\"\n _options[\"text\"] = options[:prompt] || \"\"\n _options[\"items\"] = items\n# _options[\"text\"] = options[:default] || \"\" # no way to specify default item?\n return_value = cocoa_dialog(\"dropdown\", _options)\n return_value = return_value.first if return_value.is_a? Array\n\n if return_value == nil then\n block_given? ? raise(SystemExit) : nil\n else\n block_given? ? yield(return_value) : return_value\n end\n end\n end",
"def getSelectedItem()\n # ennek mindig az elso oszlop itemjet kell visszaadni\n #midx = @tv.selectionModel.currentIndex\n mi = @treeview.selectionModel.selectedRows.first\n return unless mi\n item = mi.model.itemFromIndex mi\n #puts \"getSelectedItem:\", mi, item\n return item, mi\n end",
"def select(*args, &block)\n browser.select(*args, &block)\n end",
"def [](i)\n values[column_index i]\n end",
"def select(*args, **options)\n call_query_method(:select, *args, **options)\n end",
"def [](idx)\n items[idx]\n end",
"def item(index = self.index)\n @data[index]\n end",
"def ListView_SetSelectedColumn(hwnd, iCol) send_listview_message(hwnd, LVM_SETSELECTEDCOLUMN, wparam: iCol) end",
"def items\n load_selection\n import_selection or render_select\n end",
"def select_with_name(val)\n option_locator = \"label=regexi:^#{val}$\"\n @driver.sc_select(:view, option_locator, self.abs_path)\n stall :select\n end",
"def adhoc_select(list, selection)\n sorted_list = adhoc_sort(list)\n return sorted_list[selection]\n end",
"def set_selected(item_no)\n if @selected\n @selected=item_no\n @item[@selected].contents.each{|x| x.contents[1].style(:fill=>salmon)}\n end\n end",
"def get_item_at(position)\n # TODO Stubbed - Required definition and implementation\n end",
"def get_item_at(position)\n # TODO Stubbed - Required definition and implementation\n end",
"def TreeView_SelectItem(hwnd, hitem) TreeView_Select(hwnd, hitem, TreeViewGetNextItem[:CARET]) end",
"def select(...)\n prompt.select(...)\n end",
"def select(*args)\n call_query_method(:select, *args)\n end",
"def selector(sel)\n if block_given?\n open(sel)\n yield\n close\n else\n chain(sel)\n end\n self\n end",
"def select_by_class_set_value(class_name, value)\n select_by_class(class_name).select value\nend"
] |
[
"0.61990607",
"0.60258186",
"0.59706527",
"0.5955629",
"0.5938615",
"0.5779483",
"0.5720658",
"0.56676394",
"0.5653086",
"0.55658346",
"0.554067",
"0.5514392",
"0.54762274",
"0.5466502",
"0.5420213",
"0.5420213",
"0.5420213",
"0.5360081",
"0.53600806",
"0.53522146",
"0.53300864",
"0.5327898",
"0.5289369",
"0.5288537",
"0.52765614",
"0.52621347",
"0.524017",
"0.524017",
"0.5229911",
"0.52086884",
"0.51922065",
"0.51857275",
"0.5181217",
"0.51797044",
"0.5148017",
"0.5136694",
"0.5130747",
"0.5130747",
"0.5123493",
"0.511999",
"0.51198995",
"0.5115408",
"0.51091665",
"0.51082206",
"0.50970304",
"0.50962645",
"0.5091174",
"0.5091174",
"0.50879276",
"0.5081914",
"0.5055242",
"0.5041168",
"0.5032365",
"0.5015269",
"0.4956639",
"0.49532714",
"0.49462628",
"0.49418885",
"0.49386573",
"0.49334407",
"0.49313533",
"0.49307567",
"0.49231523",
"0.49230808",
"0.49188685",
"0.49062192",
"0.4904924",
"0.490393",
"0.49011514",
"0.48937818",
"0.48937398",
"0.48933873",
"0.4891452",
"0.48907226",
"0.48847944",
"0.48840737",
"0.48794737",
"0.4877523",
"0.48740825",
"0.4872214",
"0.48624346",
"0.48613325",
"0.4856019",
"0.48504573",
"0.484982",
"0.48429495",
"0.48401612",
"0.4838876",
"0.4833004",
"0.48324293",
"0.48310778",
"0.48307267",
"0.48280597",
"0.48212492",
"0.481267",
"0.48104072",
"0.47988617",
"0.47958452",
"0.47926438",
"0.47883743",
"0.47865865"
] |
0.0
|
-1
|
GET /members GET /members.json
|
def index
@state = params[:status].present? ? params[:status] : "active"
if stale?([@space, @state, flash])
@members = @space.members.by_status(@state).order("name asc")
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get_members\n @user = User.find_by(user_params)\n @members = @user.members\n \n if not @members.nil?\n render json: @members\n else \n render json: \"\"\n end\n end",
"def members\n raw_response = get_request('users/members')\n parse_response(raw_response, :users)\n end",
"def list_members\n HTTP.headers(:accept => @@accept, \"content-type\" => @@content_type).basic_auth(:user => ENV[\"API_USERNAME\"], :pass => ENV[\"API_PASSWORD\"])\n .get(\"#{@@base_url}/users/#{self.guid}/members\").parse[\"members\"]\n end",
"def members\n return @members if @members\n @members = Client.get(\"/organizations/#{id}/members/all\").json_into(Member)\n end",
"def members\n response = service.get_members\n response.map do |member_data|\n Member.new(member_data)\n end\n end",
"def list_members(user, list)\n get(\"/#{user}/#{list}/members.json\")\n end",
"def members_list\n @members = Member.active.ordered.all\n @user = current_user\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @members }\n end\n end",
"def org_members\n @members = @github.orgs.members.list APP_CONF['org']\n render json: @members\n end",
"def members(options = { :filter => :all })\n return @members if @members\n @members = Client.get(\"/boards/#{id}/members\", options).json_into(Member)\n end",
"def index\n @members = Member.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def index\n @members = Member.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def index\n @members = Member.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def get_members()\n @client.make_request(:get, @client.concat_user_path(\"#{CONFERENCE_PATH}/#{id}/members\"))[0].map do |i|\n member = ConferenceMember.new(i, @client)\n member.conference_id = id\n member\n end\n end",
"def members *args\n page, per_page, options = TibbrResource.extract_params(args, 2)\n cache_lookup(MEMBERS, true, page, per_page) do\n TibbrResource.paginate_collection(get(:members, :params => {:include_group_members => options[:include_group_members], :page => page, :per_page => per_page}), User)\n end\n end",
"def members\n users\n end",
"def members\n users\n end",
"def team_members(id)\n get \"/teams/#{id}/members\"\n end",
"def index\n @members = Member.members\n @participants = Member.participants\n @invited_count = Member.count\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def conference_list_members(params)\n path = @version + '/Conference/Member/List/'\n method = 'POST'\n return request(path, method, params)\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def members(options = {})\n KlaviyoAPI::ListMember.all_members params: { list_id: id, **options }\n end",
"def index\n @members = Member.find(:all)\n end",
"def index\n @members = User::Member.all\n end",
"def get_member_of_list(user, list, member_id)\n get(\"/#{user}/#{list}/members/#{member_id}.json\")\n end",
"def group_members(id)\n get(\"/groups/#{id}/members\")\n end",
"def members\n # Include the join model, because we want the serializer to set\n # the ready flag on the user.\n @room = Room.includes(:room_users).find(params.require(:room_id))\n if @room && current_user.member_of_room?(@room)\n success(body: @room.members, scope: { room: @room })\n else\n not_found\n end\n end",
"def vault_members(vault_id)\n request_get(\"/vault/#{vault_id}/members\")\n end",
"def index\n if params[:data]\n @members = Member.get_members(params[:data][:kind].to_i, params[:data][:search])\n else\n @members = Member.all\n end\n\n @members = @members.paginate(:page => params[:page], :per_page => 25)\n end",
"def members\n fetch if @members.nil? || @members[0].nil?\n @members\n end",
"def get\r\n\t\t#binding.pry\r\n\t\ttemplateFile = 'api/v1/users/members/get'\r\n\t\tunless (params[:id].to_i != 0 ) #will get the current user id if its nil or 0\r\n\t\t\tparams[:id] = session[:user].id\r\n\t\t\ttemplateFile = 'api/v1/users/members/getFull'\r\n\t\tend\r\n @responseObject = OpenStruct.new({\r\n status: true,\r\n errors: [],\r\n code: API_CODE_ERRORS['Services']['Global']['success'],\r\n objectData: OpenStruct.new(User.getFullUserData(params[:id])),\r\n timestamp: (Date.new).to_time.to_i.abs\r\n })\r\n \trender :template => templateFile ,:handlers => [:rabl], :formats => [:json]\r\n\tend",
"def index\n @search = Member.search(params[:search])\n @members = @search.paginate(:page => params[:page])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def memberships\n @list.client.get(\"#{url}/memberships\")\n end",
"def members( params={} )\n members = get_connections(\"members\", params)\n return map_connections members, :to => Facebook::Graph::Generic\n end",
"def search_members(query, options = {})\n get search_path(\"members\"), options.merge(query: query)\n end",
"def index\n @restmembers = Restmember.all\n end",
"def organization_members(org)\n get \"/orgs/#{org}/members\"\n end",
"def get_all_members(params = {})\n room_id = self.room_id || params.delete(:room_id)\n raise ArgumentError.new(\"room_id required\") unless room_id\n res = call_api(:method => :get, :uri => @api_base.merge(\"room/#{room_id}/member\"), :query_params => params)\n return unless res.successful?\n Users.new(res.data)\n end",
"def all_members(**params)\n client.api.get_room_members(id, **params)[:chunk].map { |ch| client.get_user(ch[:state_key]) }\n end",
"def index\n\t\tmembers = Member.where(team_id: params[:team_id]).all\n\t\trespond_with members\n\tend",
"def members\n @group = Group.find(params[:group_id])\n @members = @group.users\n end",
"def index\n @members = @project.memebers\n end",
"def show_members\n @members.each do |member, amt|\n puts member\n end\n @members\n end",
"def members\n resp = MU::Cloud::Google.admin_directory(credentials: @credentials).list_members(@cloud_id)\n members = []\n if resp and resp.members\n members = resp.members.map { |m| m.email }\n# XXX reject status != \"ACTIVE\" ?\n end\n members\n end",
"def members_get_info(members:, trace: false)\n members_json = []\n members.each do |m|\n if m['team_member_id'] != nil\n members_json << \"{\\\".tag\\\":\\\"team_member_id\\\",\\\"team_member_id\\\":\\\"#{m['team_member_id']}\\\"}\"\n elsif m['external_id'] != nil\n members_json << \"{\\\".tag\\\":\\\"external_id\\\",\\\"external_id\\\":\\\"#{m['external_id']}\\\"}\"\n elsif m['email'] != nil\n members_json << \"{\\\".tag\\\":\\\"email\\\",\\\"email\\\":\\\"#{m['email']}\\\"}\"\n end\n end\n dropbox_query(query: '2/team/members/get_info', query_data: \"{\\\"members\\\":[#{members_json.join(',')}]}\", trace: trace)\n end",
"def members()\n return MicrosoftGraph::Me::JoinedTeams::Item::Members::MembersRequestBuilder.new(@path_parameters, @request_adapter)\n end",
"def users(args = {})\n get(\"/users.json\",args)\n end",
"def show\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def group_members(id, params = {})\n get(\"/groups/#{id}/members\", params)\n end",
"def members\n @members\n end",
"def members\n @members\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def member(token, server_id, user_id)\n request(\n __method__,\n :get,\n \"#{api_base}/guilds/#{server_id}/members/#{user_id}\",\n Authorization: token\n )\n end",
"def getMembersList()\n\t\tbegin\n\t \t@members=[];\n\t \tuserMembers = TwitterClient.list_members(@selectedList)\n\t \tuserMembers.each do |memberInList|\n\t \t\t@members << memberInList.id\n\t \tend\n\t \t@members\n\t rescue\n\t \t-1\n\t end\n\tend",
"def index\n @member = Member.find(params[:member_id])\n end",
"def index\n if params[:group_id]\n @members = Group.find(params[:group_id]).members\n else\n @members = Member.all\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @member }\n end\n end",
"def show\n if user\n render json: user,serializer: Api::V1::MembersSerializer, :status => 201\n else\n render json: \"errors\", :status => 422\n end \n end",
"def user_team_members(id, user_id = nil)\n user_id.to_i.zero? ? get(\"/user_teams/#{id}/members\") : get(\"/user_teams/#{id}/members/#{user_id}\")\n end",
"def get_mailing_members(id)\n get(\"/mailings/#{id}/members\")\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @member }\n end\n end",
"def show\n team = Team.find(params[:id])\n image_url = team.image.url\n members = team.members.select(:name, :surname)\n member_names = []\n members.each do |m|\n member_names.push(m.name + \" \" + m.surname)\n end\n team = team.attributes\n\n team[:members] = member_names\n team[:image] = image_url\n render json: team\n end",
"def all_members\n @dvd_club = DvdClub.find(params[:id])\n @users = @dvd_club.users\n end",
"def index\n @members = Defer { ::Member.all }\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @members }\n end\n end",
"def new_members\n @members = User.all\n end",
"def list_memberships(user)\n get(\"/#{user}/lists/memberships.json\")\n end",
"def users\n GroupMembers.new(:id => id).get.items\n end",
"def members\n participants\n end",
"def members\n participants\n end",
"def members\n @members ||= ApiFactory.new 'Orgs::Members'\n end",
"def show_members\n @exchange = Exchange.find(params[:id])\n @members = @exchange.users\n @exchanges = current_user.exchanges.find(:all)\n end",
"def show\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @membership }\n end\n end",
"def members options = {}\n options[\"members\"] = true\n result = JSON.parse(rbac_role_resource[options_querystring options].get)\n if result.is_a?(Hash) && ( count = result['count'] )\n count\n else\n parser_for(:members, credentials, result)\n end\n end",
"def organization_public_members(org)\n get \"/orgs/#{org}/public_members\"\n end",
"def memberships\n prefix = \"#{path_prefix}/memberships\"\n Ghee::API::Users::Memberships::Proxy.new(connection, prefix)\n end",
"def get_members_by_id\n return filter_by_id(get_members) \n end",
"def team_members(id)\n Hardmode.get(\"/teams/#{id}/members\", :headers => @auth) \n list = results.map do |result|\n result[\"login\"]\n end\n list\n end",
"def members(options = {})\n Tinybucket::Resource::Team::Members.new(username, options)\n end",
"def member(member_id, &block)\n get \"/member/#{member_id}/\", nil, &block\n end",
"def get_group_members\n\t\tid = params[:id]\n\n #Get the initial call of members in the group\n members_initial = TheCityAdmin::GroupRoleList.new({:group_id => id})\n @total_count = members_initial.total_pages\n @members = Array.new\n\n members_initial.each do |member|\n @members << member\n end\n\n if Rcplugin::DEV_ENV == true\n puts \"CTDEBUG: Total pages to get #{members_initial.total_pages}\"\n puts 'CTDEBUG: Group list for id: ' + id\n puts members_initial.to_json\n end\n\n #If there is more than one page loop through all the pages and then return\n if @total_count > 1\n for i in 2..@total_count\n TheCityAdmin::AdminApi.connect(Rcplugin::CITY_ADMIN_SECRET,Rcplugin::CITY_USER_TOKEN)\n members = TheCityAdmin::GroupRoleList.new({:group_id => id,:page => i})\n members.each do |member|\n @members << member\n end\n end\n end\n\n if Rcplugin::DEV_ENV == true\n puts 'CTDEBUG: Final members list in JSON'\n puts @members.to_json\n end\n\n\t\trender json: @members.to_json\n\tend",
"def index\n @oc_members = OcMember.find(:all, :order => \"created_at ASC\")\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @oc_members }\n end\n end",
"def get_profile\n self.class.get '/members/private', @options\n end",
"def index\n @announcements = Announcement.all\n render json: @announcements, include: [:member => {only: [:first_name, :last_name, :id]}]\n end",
"def members\n if @memorial\n @pagination = {\n q: params[:q].nil? ? \"\" : params[:q],\n p: params[:p].nil? ? \"1\" : params[:p],\n per_p: params[:per_p].nil? ? \"10\" : params[:per_p],\n total: 0,\n order: {\n column: @order.column,\n dir: @order.direction\n }\n }\n @users = @memorial.users\n .reorder(@order.column => @order.direction)\n .ransack(first_name_or_last_name_or_email_cont_any: @pagination[:q].split(\" \")).result\n @pagination[:total] = @users.length\n @users = @users\n .paginate(page: @pagination[:p], per_page: @pagination[:per_p])\n user_memorials = []\n @users.each do |u|\n user_memorials << u.user_memorials.find_by(memorial_id: @memorial[:uuid])\n end\n user = user_memorials.as_json({\n include: [{user: {only: [:uuid, :first_name, :last_name, :email]}}, {role: {only: [:uuid, :name]}}]\n })\n users = []\n user.each do |u|\n entity = {\n uuid: u['user']['uuid'],\n first_name: u['user']['first_name'],\n last_name: u['user']['last_name'],\n email: u['user']['email'],\n roles: [u['role']]\n }\n users << entity\n end\n response = {\n organization: @memorial[:organization_id].present? ? Organization.where(uuid: @memorial[:organization_id]).select(\"uuid, name, address, image, posY, posX, scale, rot\") : nil,\n results: users,\n pagination: @pagination\n }\n render json: response\n else\n render json: {error: 'You do not have access to this memorial'}, status: 422\n end\n end"
] |
[
"0.85555315",
"0.8368444",
"0.80864495",
"0.79692763",
"0.79227495",
"0.7810278",
"0.7673862",
"0.7492891",
"0.74862355",
"0.7484284",
"0.7484284",
"0.7484284",
"0.7377688",
"0.7360226",
"0.7336541",
"0.7336541",
"0.7235276",
"0.7182636",
"0.718245",
"0.71680915",
"0.71680915",
"0.71680915",
"0.71680915",
"0.71680915",
"0.71680915",
"0.71680915",
"0.71680915",
"0.71680915",
"0.71680915",
"0.7154878",
"0.7149369",
"0.7103185",
"0.70743614",
"0.6984045",
"0.69625366",
"0.69603014",
"0.69270116",
"0.6917607",
"0.68976516",
"0.68928814",
"0.68855894",
"0.6877435",
"0.6876831",
"0.68652534",
"0.6836881",
"0.6830693",
"0.6815115",
"0.68032235",
"0.6781551",
"0.67748606",
"0.67669946",
"0.67616576",
"0.6751916",
"0.6733912",
"0.67120314",
"0.6692614",
"0.667964",
"0.664444",
"0.664444",
"0.6614896",
"0.6614896",
"0.6614896",
"0.6614896",
"0.6614896",
"0.6614896",
"0.6614896",
"0.6614896",
"0.6614896",
"0.66023093",
"0.6596358",
"0.65810806",
"0.65798175",
"0.65597105",
"0.65597105",
"0.6558795",
"0.65438014",
"0.65375996",
"0.6519117",
"0.65100586",
"0.6508006",
"0.65056163",
"0.64901036",
"0.6484866",
"0.64811397",
"0.6468305",
"0.6468305",
"0.6458759",
"0.6452758",
"0.6450333",
"0.644986",
"0.64389265",
"0.64386964",
"0.64274263",
"0.6398766",
"0.6395538",
"0.63942546",
"0.63939685",
"0.63936025",
"0.6372155",
"0.6366832",
"0.6365905"
] |
0.0
|
-1
|
GET /members/1 GET /members/1.json
|
def show
if stale?([@member, flash])
@ledger_items = @member.member_invoices.order("created_at desc")
@history_items = @member.ledger_items
.where(status: ["closed", "cleared", "failed"])
.order("created_at desc")
.limit(6)
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get_members\n @user = User.find_by(user_params)\n @members = @user.members\n \n if not @members.nil?\n render json: @members\n else \n render json: \"\"\n end\n end",
"def members\n raw_response = get_request('users/members')\n parse_response(raw_response, :users)\n end",
"def index\n @members = Member.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def index\n @members = Member.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def index\n @members = Member.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def list_members\n HTTP.headers(:accept => @@accept, \"content-type\" => @@content_type).basic_auth(:user => ENV[\"API_USERNAME\"], :pass => ENV[\"API_PASSWORD\"])\n .get(\"#{@@base_url}/users/#{self.guid}/members\").parse[\"members\"]\n end",
"def get_member_of_list(user, list, member_id)\n get(\"/#{user}/#{list}/members/#{member_id}.json\")\n end",
"def list_members(user, list)\n get(\"/#{user}/#{list}/members.json\")\n end",
"def members\n return @members if @members\n @members = Client.get(\"/organizations/#{id}/members/all\").json_into(Member)\n end",
"def members\n response = service.get_members\n response.map do |member_data|\n Member.new(member_data)\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def members_list\n @members = Member.active.ordered.all\n @user = current_user\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @members }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @member }\n end\n end",
"def index\n @member = Member.find(params[:member_id])\n end",
"def show\n @member = Member.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @member }\n end\n end",
"def get\r\n\t\t#binding.pry\r\n\t\ttemplateFile = 'api/v1/users/members/get'\r\n\t\tunless (params[:id].to_i != 0 ) #will get the current user id if its nil or 0\r\n\t\t\tparams[:id] = session[:user].id\r\n\t\t\ttemplateFile = 'api/v1/users/members/getFull'\r\n\t\tend\r\n @responseObject = OpenStruct.new({\r\n status: true,\r\n errors: [],\r\n code: API_CODE_ERRORS['Services']['Global']['success'],\r\n objectData: OpenStruct.new(User.getFullUserData(params[:id])),\r\n timestamp: (Date.new).to_time.to_i.abs\r\n })\r\n \trender :template => templateFile ,:handlers => [:rabl], :formats => [:json]\r\n\tend",
"def show\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def index\n @members = Member.find(:all)\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def index\n @members = Member.all\n end",
"def team_members(id)\n get \"/teams/#{id}/members\"\n end",
"def org_members\n @members = @github.orgs.members.list APP_CONF['org']\n render json: @members\n end",
"def get_members()\n @client.make_request(:get, @client.concat_user_path(\"#{CONFERENCE_PATH}/#{id}/members\"))[0].map do |i|\n member = ConferenceMember.new(i, @client)\n member.conference_id = id\n member\n end\n end",
"def index\n @members = User::Member.all\n end",
"def member(member_id, &block)\n get \"/member/#{member_id}/\", nil, &block\n end",
"def show\n @member = Member.find(params[:id])\n @title = \"#{@member.last_name} #{@member.given_names}\"\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def index\n @members = Member.members\n @participants = Member.participants\n @invited_count = Member.count\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def members *args\n page, per_page, options = TibbrResource.extract_params(args, 2)\n cache_lookup(MEMBERS, true, page, per_page) do\n TibbrResource.paginate_collection(get(:members, :params => {:include_group_members => options[:include_group_members], :page => page, :per_page => per_page}), User)\n end\n end",
"def members\n users\n end",
"def members\n users\n end",
"def members(options = { :filter => :all })\n return @members if @members\n @members = Client.get(\"/boards/#{id}/members\", options).json_into(Member)\n end",
"def show\n if user\n render json: user,serializer: Api::V1::MembersSerializer, :status => 201\n else\n render json: \"errors\", :status => 422\n end \n end",
"def index\n @members = @project.memebers\n end",
"def show\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @membership }\n end\n end",
"def member(token, server_id, user_id)\n request(\n __method__,\n :get,\n \"#{api_base}/guilds/#{server_id}/members/#{user_id}\",\n Authorization: token\n )\n end",
"def index\n if params[:data]\n @members = Member.get_members(params[:data][:kind].to_i, params[:data][:search])\n else\n @members = Member.all\n end\n\n @members = @members.paginate(:page => params[:page], :per_page => 25)\n end",
"def account\n @member = current_user.member\n @user = current_user\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @member }\n end\n end",
"def show\n team = Team.find(params[:id])\n image_url = team.image.url\n members = team.members.select(:name, :surname)\n member_names = []\n members.each do |m|\n member_names.push(m.name + \" \" + m.surname)\n end\n team = team.attributes\n\n team[:members] = member_names\n team[:image] = image_url\n render json: team\n end",
"def index\n @search = Member.search(params[:search])\n @members = @search.paginate(:page => params[:page])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def group_members(id)\n get(\"/groups/#{id}/members\")\n end",
"def members\n fetch if @members.nil? || @members[0].nil?\n @members\n end",
"def index\n @restmembers = Restmember.all\n end",
"def show\n @membership = Membership.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @membership }\n end\n end",
"def show\n @group_member = GroupMember.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @group_member }\n end\n end",
"def show\n @group_member = GroupMember.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @group_member }\n end\n end",
"def show\n @member = Member.find(params[:id])\n raise CanCan::AccessDenied if cannot? :show, @member\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member }\n end\n end",
"def index\n\t\tmembers = Member.where(team_id: params[:team_id]).all\n\t\trespond_with members\n\tend",
"def members(options = {})\n KlaviyoAPI::ListMember.all_members params: { list_id: id, **options }\n end",
"def show_members\n @members.each do |member, amt|\n puts member\n end\n @members\n end",
"def index\n if params[:single]\n\t url = \"#{API_BASE_URL}/users/#{params[:id]}.json\"\n\t response = RestClient.get(url)\n\t @user = JSON.parse(response.body)\n\telse\n\t url = \"#{API_BASE_URL}/users.json\"\t \n response = RestClient.get(url)\n @users = JSON.parse(response.body)\t\t \n\tend\n end",
"def get_profile\n self.class.get '/members/private', @options\n end",
"def show_member\n @member = Member.find(params[:id])\n end",
"def show\n @member_type = MemberType.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @member_type }\n end\n end",
"def members_get_info(members:, trace: false)\n members_json = []\n members.each do |m|\n if m['team_member_id'] != nil\n members_json << \"{\\\".tag\\\":\\\"team_member_id\\\",\\\"team_member_id\\\":\\\"#{m['team_member_id']}\\\"}\"\n elsif m['external_id'] != nil\n members_json << \"{\\\".tag\\\":\\\"external_id\\\",\\\"external_id\\\":\\\"#{m['external_id']}\\\"}\"\n elsif m['email'] != nil\n members_json << \"{\\\".tag\\\":\\\"email\\\",\\\"email\\\":\\\"#{m['email']}\\\"}\"\n end\n end\n dropbox_query(query: '2/team/members/get_info', query_data: \"{\\\"members\\\":[#{members_json.join(',')}]}\", trace: trace)\n end",
"def get_mailing_members(id)\n get(\"/mailings/#{id}/members\")\n end",
"def get_members_by_id\n return filter_by_id(get_members) \n end",
"def show\n @aiit_member = AiitMember.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @aiit_member }\n end\n end",
"def conference_list_members(params)\n path = @version + '/Conference/Member/List/'\n method = 'POST'\n return request(path, method, params)\n end",
"def user_team_members(id, user_id = nil)\n user_id.to_i.zero? ? get(\"/user_teams/#{id}/members\") : get(\"/user_teams/#{id}/members/#{user_id}\")\n end",
"def show\n \t@member= Member.find(params[:member_id])\n\tend",
"def members\n @group = Group.find(params[:group_id])\n @members = @group.users\n end",
"def show\n @clnmember = Clnmember.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @clnmember }\n end\n end",
"def vault_members(vault_id)\n request_get(\"/vault/#{vault_id}/members\")\n end",
"def show\n #@member= Member.find(params[:member_id])\n end",
"def show\n #@member= Member.find(params[:member_id])\n end",
"def show\n #@member= Member.find(params[:member_id])\n end",
"def index\n if params[:group_id]\n @members = Group.find(params[:group_id]).members\n else\n @members = Member.all\n end\n end",
"def index\n @members = Defer { ::Member.all }\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @members }\n end\n end",
"def index\n @announcements = Announcement.all\n render json: @announcements, include: [:member => {only: [:first_name, :last_name, :id]}]\n end",
"def show\n @membership = Adhocracy::Membership.find(params[:id])\n\n render json: @membership\n end",
"def show\n\t\t@member = Member.find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tformat.html # show.html.erb\n\t\t\tformat.xml\t{ render :xml => @member }\n\t\tend\n\tend",
"def index\n @oc_members = OcMember.find(:all, :order => \"created_at ASC\")\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @oc_members }\n end\n end",
"def index\n @member = Member.find(params[:member_id])\n\n @maritalinfos = @member.maritalinfo\n end",
"def member\n Member.find(@member.name)\n end",
"def show\n # GET /gym_members/:id\n @gym_member = GymMember.find(params[:id])\n render :show\n end",
"def group_members(id, params = {})\n get(\"/groups/#{id}/members\", params)\n end",
"def index\n @member = Member.find(params[:member_id])\n\n @personalinfos = @member.personalinfo\n end",
"def get_member(_user_id)\n user_participants.where(id: _user_id).take\n end",
"def show\n @member = Member.find(params[:id])\n #@members = Member.paginate(:page => params[:page])\n @title = @member.last_name\n #respond_to do |format|\n # format.html # show.html.erb\n # format.xml { render :xml => @member }\n #end\n end",
"def members\n # Include the join model, because we want the serializer to set\n # the ready flag on the user.\n @room = Room.includes(:room_users).find(params.require(:room_id))\n if @room && current_user.member_of_room?(@room)\n success(body: @room.members, scope: { room: @room })\n else\n not_found\n end\n end",
"def all_members\n @dvd_club = DvdClub.find(params[:id])\n @users = @dvd_club.users\n end",
"def test_get_member_basic_success\n\n client = create_mock_client\n refute_nil client, \"Client object couldn't be created.\"\n\n stub_request(:get, mock_uri('Groups', '17', 'Members', '15'))\n .to_return(status: 200, body: { 'Success' => true,\n 'Message' => \"Operation succeeded\",\n 'ApiId' => API_ID,\n 'Member' => { 'Id' => 15,\n 'Name' => 'someone',\n 'Number' => '91XXXXXXXXXX' } }.to_json)\n\n status, member = client.group.get_member(17, 15)\n refute_nil status, \"No status object returned.\"\n assert status.success, \"Status did not indicate success: \" + status.message.to_s\n refute_nil member, \"No member item returned.\"\n assert_equal 15, member.id, \"ID is not correct.\"\n assert_equal 'someone', member.name, \"Name is not correct.\"\n assert_equal '91XXXXXXXXXX', member.number, \"Number is not correct.\"\n\n end",
"def show\n @family_member = FamilyMember.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @family_member }\n end\n end",
"def show\n @family_member = FamilyMember.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @family_member }\n end\n end"
] |
[
"0.8023607",
"0.74336106",
"0.7342003",
"0.7342003",
"0.7342003",
"0.73214304",
"0.7298026",
"0.72192717",
"0.7218691",
"0.7147416",
"0.7146131",
"0.7146131",
"0.7146131",
"0.7146131",
"0.7146131",
"0.7146131",
"0.7146131",
"0.7146131",
"0.7146131",
"0.71341074",
"0.70936525",
"0.70936525",
"0.70766354",
"0.7053166",
"0.7035738",
"0.7028867",
"0.69767696",
"0.6938388",
"0.6938388",
"0.6938388",
"0.6938388",
"0.6938388",
"0.6938388",
"0.6938388",
"0.6938388",
"0.6938388",
"0.6938388",
"0.6933961",
"0.69334745",
"0.6927727",
"0.6885265",
"0.6878668",
"0.6864126",
"0.68585396",
"0.68532085",
"0.68323547",
"0.68323547",
"0.6806996",
"0.6772676",
"0.6694691",
"0.66415876",
"0.66394323",
"0.662955",
"0.6620445",
"0.6609186",
"0.66012996",
"0.65918463",
"0.65861684",
"0.6578387",
"0.65486526",
"0.65302163",
"0.65302163",
"0.65055513",
"0.65011716",
"0.6493538",
"0.6489075",
"0.6477896",
"0.6468778",
"0.64574265",
"0.6448352",
"0.6443409",
"0.6439681",
"0.64128935",
"0.6408956",
"0.63888496",
"0.63874215",
"0.6372082",
"0.6368453",
"0.63614684",
"0.63607746",
"0.63433164",
"0.63433164",
"0.63433164",
"0.6338339",
"0.6333715",
"0.63101363",
"0.6302169",
"0.62862915",
"0.62773913",
"0.6272662",
"0.62713706",
"0.62684464",
"0.6262141",
"0.62564564",
"0.6255515",
"0.6251802",
"0.62317294",
"0.62316513",
"0.62301344",
"0.6227782",
"0.6227782"
] |
0.0
|
-1
|
POST /members POST /members.json
|
def create
@member = @space.members.new(member_params)
@member.user = current_user
respond_to do |format|
if @member.save
@space.members << @member
format.html { redirect_to space_member_url(@space, @member), notice: 'Member was successfully created.' }
format.json { render :show, status: :created, location: [@space, @member] }
else
format.html { render :new }
format.json { render json: @member.errors, status: :unprocessable_entity }
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def add_member_to_list(user, list, member_id, options={})\n post(\"/#{user}/#{list}/members.json\", options.merge(:id => member_id))\n end",
"def create_member(data)\n headers = @client.make_request(:post, @client.concat_user_path(\"#{CONFERENCE_PATH}/#{id}/members\"), data)[1]\n id = Client.get_id_from_location_header(headers[:location])\n get_member(id)\n end",
"def create\n @member = @current_enterprise.members.build(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new_members\n @members = User.all\n end",
"def create_members\n project = Project.find(params[:id])\n\n params[:members].each do |member_id|\n user = User.find(member_id)\n project.users << user unless project.users.include?(user) \n end\n \n respond_to do |format|\n format.html { redirect_to project_path(@project), notice: 'members were successfully added.' }\n format.json { render json: @project, status: :created, location: @project }\n end\n end",
"def create\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render json: @member, status: :created, location: @member }\n else\n format.html { render action: \"new\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(params[:member])\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render json: @member, status: :created, location: @member }\n else\n format.html { render action: \"new\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(params[:member])\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render json: @member, status: :created, location: @member }\n else\n format.html { render action: \"new\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(params[:member])\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render json: @member, status: :created, location: @member }\n else\n format.html { render action: \"new\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n flash[:notice] = 'Member Created' if @project.members << @member\n respond_with @project, @member\n end",
"def create\n # type = \"member\"\n\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render action: 'show', status: :created, location: @member }\n else\n format.html { render action: 'new' }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to admin_member_path(@member), notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.json { render :show, status: :created, location: @member }\n else\n return api_error(status: :unprocessable_entity, message: @member.errors)\n end\n end\n end",
"def create\n @member = @organization.members.build(member_params)\n\n respond_to do |format|\n if @member.save\n logger.info(\"User #{current_user.email} created Member '#{@member.first_name} #{@member.last_name}' on #{@member.updated_at}\")\n format.html { redirect_to organization_path(@organization), notice: 'Member was successfully created.' }\n #format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def get_members\n @user = User.find_by(user_params)\n @members = @user.members\n \n if not @members.nil?\n render json: @members\n else \n render json: \"\"\n end\n end",
"def create\n\tif !checkadmin? then return end\n @member = Member.new(params[:member])\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render json: @member, status: :created, location: @member }\n else\n format.html { render action: \"new\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n #sanity checks, can only modify memberships that you own\n if params[:user_id].to_i != current_user.id then\n render json: {message:'You do not own the membership list'}, :status => :unprocessable_entity\n return\n end\n\n #ensure the membership params is there\n unless params.has_key? :memberships then\n #render json: {message:'memberships list not found'}, :status => :unprocessable_entity\n #return\n #this could me no membership at all\n params[:memberships] = {}\n end\n\n #set the new memberships state\n current_user.set_memberships params[:memberships]\n\n render json: {\n message:'message received from server',\n memberships:User.find(params[:user_id]).memberships.map{ |x| x.attributes.merge({club_name: x.club_name})}\n }\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save!\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = User.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save \n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @membership = @member.memberships.build(membership_params)\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership.member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n if current_member.can_admin_members?\n @member = Member.new(params[:member])\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render json: @member, status: :created, location: @member }\n else\n # raise YAML::dump(@member)\n # raise @member.errors[0].to_s\n format.html { render action: \"new\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n else\n render_forbidden\n end\n end",
"def members\n raw_response = get_request('users/members')\n parse_response(raw_response, :users)\n end",
"def conference_list_members(params)\n path = @version + '/Conference/Member/List/'\n method = 'POST'\n return request(path, method, params)\n end",
"def add_member(id, user)\n client.post(\"#{path}/#{id}/members\", user)\n end",
"def members\n response = service.get_members\n response.map do |member_data|\n Member.new(member_data)\n end\n end",
"def post(member, request_opts={})\n unless member.is_a?(User)\n raise DataTypeError.new(\"User object is expected, but got [#{member.inspect}]\")\n end\n member = GroupMember.new(:group_id => self.id, :member_id => member.id)\n http(request_opts).post(resolved_path, member.as_hash)\n end",
"def create\n @member = Member.new(member_params)\n unless @member.set_region_admin == \"1\"\n @member.region_id = current_member.region_id\n end\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n @uplines = Member.order(\"fullname\")\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @group_member = @client.group_members.new(group_member_params)\n respond_to do |format|\n if @group_member.save\n format.html { redirect_to client_group_member_path(@client,@group_member), notice: 'Group member was successfully created.' }\n format.json { render :show, status: :created, location: @group_member }\n else\n format.html { render :new }\n format.json { render json: @group_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @membership = Membership.new(params[:membership])\n @membership.member = current_member\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to sub_clubs_path, :notice => 'You requested membership.' }\n format.json { render :json => @membership, :status => :created, :location => @membership }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(create_params)\n respond_to do |format|\n if @member.save\n session[:member_id] = @member.id\n format.html { redirect_to @member }\n format.json { render action: 'show', status: :created, location: @member }\n else\n format.html { render action: 'new' }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n r = params[:member]\n @member = Member.where(:email => r[:email], :group_name => r[:group_name], :admin_uuid => session[:user_uuid]).first\n r = @member.attributes.merge(r) unless @member.nil?\n @member = Member.new(r) if @member.nil?\n @member.update_attributes(r) unless @member.nil?\n\n unless @member.err\n @member.get_member_uuid\n end\n respond_to do |format|\n unless @member.nil?\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render json: @member, status: :created, location: @member }\n else\n format.html { render action: \"new\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n \n\n respond_to do |format|\n if @member.save\n format.html { redirect_to groups_path, notice: \"Member was successfully created.\" }\n format.json { render :show, status: :created, location: @member }\n format.js\n else\n format.html { redirect_back fallback_location: root_path, status: :unprocessable_entity }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: '出欠情報を保存しました' }\n format.json { render action: 'show', status: :created, location: @member }\n else\n format.html { render action: 'new' }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n r = params[:member]\n @member = Member.where(:email => r[:email], :group_name => r[:group_name], :admin_uuid => session[:user_uuid]).first\n r = @member.attributes.merge(r) unless @member.nil?\n @member = Member.new(r) if @member.nil?\n @member.update_attributes(r) unless @member.nil?\n unless @member.err\n @member.get_member_uuid\n end\n respond_to do |format|\n unless @member.nil?\n format.html { redirect_to @member, notice: 'Member was successfully created.' }\n format.json { render json: @member, status: :created, location: @member }\n else\n format.html { render action: \"new\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to controller: :login, action: :index, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new, layout: 'member_new' }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = GroupMember.new(params[:member])\n if @current_member.group.add_member @member\n render :json=>{success:true, new_id:@member.id}\n UserMailer.invite_email(@member.email).deliver\n else\n render :json=>{success:false, errors:@member.errors}\n end\n end",
"def create_team_member\n clinics = params[:clinics].split(\", \")\n\n team_member = TeamMember.create(\n email: params[:email],\n first_name: params[:first_name],\n last_name: params[:last_name],\n user: params[:user],\n status: \"Active\",\n role: params[:role]\n )\n\n clinics.each do |clinic|\n Clinic.find(clinic).team_members << team_member\n end\n\n render json: team_member, include: ['clinics']\n end",
"def sign_up\n\t\tif params[:uuid].present?\n\t\t\t@existing_member = Com::Nbos::User.where(uuid: params[:uuid])\n\t\t\tif @existing_member.present?\n\t\t\t\trender :json => @existing_member.first\n\t\t\telse\n\t\t\t\t@member = build_user(params)\n\t\t\t\tif @member && @member.save\n\t\t\t\t\trender :json => @member\n\t\t\t\telse\n\t\t\t\t\trender :json => {status: 500, message: @member.errors.messages}, status: 500\n\t\t\t\tend\n\t\t\tend\n\t\telse\n\t\t\trender :json => {status: 400, message: \"Bad Request\"}, status: 400\n\t\tend\t\n\tend",
"def create\n\t\t@member = Member.new(params[:member])\n\n\t\trespond_to do |format|\n\t\t\tif @member.save\n\t\t\t\tformat.html { redirect_to(@member.membership, :notice => 'Member was successfully created.') }\n\t\t\t\tformat.xml\t{ render :xml => @member, :status => :created, :location => @member }\n\t\t\telse\n\t\t\t\tformat.html { render :action => \"new\" }\n\t\t\t\tformat.xml\t{ render :xml => @member.errors, :status => :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def create\n @member = Member.new(params[:member])\n @member.house = current_member.house\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to root_url, notice: 'Member was successfully created.' }\n format.json { render json: @member, status: :created, location: @member }\n else\n format.html { render action: \"new\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_members\n members_ids = params[:contest][:members].reject(&:empty?)\n @contest.members.destroy_all if params[:action] == \"update\"\n members_ids.each do |members_id|\n member = Member.create(:user_id => members_id.to_i, :invitable => @contest)\n #send notification\n reciver = User.find(members_id)\n notifications = reciver.notifications.unread \n if reciver.notification_setting.try(:new_update)\n Notification.create(recepient_id: members_id, user: current_user, body: \"#{current_user.screen_name } has invited you to join a contest #{@contest.topic} \", notificable: @contest, :accept => false, :is_acceptable=>true)\n PrivatePub.publish_to \"/profiles/new_#{members_id}\", \"jQuery('#all-notifications').html('#{notifications.count}'); jQuery('#all-notifications').addClass('push-notification');\"\n\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n @creating_member = true\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'El miembro ha sido creado' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Member created.' }\n else\n format.html { render :new }\n end\n end\n end",
"def member_params\n params.require(:member).permit(:first_name, :last_name, :email)\n end",
"def create\n @member = Member.new(member_params)\n @member.save\n if @member.save\n redirect_to members_path\n else render :new\n end\n end",
"def create\n @member = Member.new(params[:member])\n\n respond_to do |format|\n if @member.save\n add_plan_to_user_if_specified!\n \n format.html { redirect_to(@member, :notice => 'Member was successfully created.') }\n format.json { render :json => @member, :status => :created, :location => @member }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n if check_if_field_empty(member_params)\n respond_to do |format|\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n else\n @member = User.new(member_params)\n @member.tenant_id = current_tenant.id\n respond_to do |format|\n if @member.save\n add_roles(params[:roles])\n format.html { redirect_to member_path(@member), notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end\n end",
"def index\n @members = Member.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def index\n @members = Member.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def index\n @members = Member.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def members_list\n @members = Member.active.ordered.all\n @user = current_user\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @members }\n end\n end",
"def create\n puts \"Is it here!?!?!\"\n @member = Member.new(params[:member])\n respond_to do |format|\n if @member.save \n format.html { redirect_to(@member, :notice => 'Member was successfully created.') }\n format.xml { render :xml => @member, :status => :created, :location => @member }\n format.json {render :json => @member, :status => :created, :location => @member }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @member = Member.new\n \n \n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @member }\n end\n end",
"def list_members(user, list)\n get(\"/#{user}/#{list}/members.json\")\n end",
"def create\n @membership = Adhocracy::Membership.new(membership_params)\n\n if @membership.save\n render json: @membership, status: :created, location: api_v1_membership_path(@membership)\n else\n render_validation_errors @membership.errors\n end\n end",
"def CreateMembership params = {}\n \n APICall(path: 'group_memberships.json',method: 'POST',payload: params.to_json)\n \n end",
"def index\n @members = Member.members\n @participants = Member.participants\n @invited_count = Member.count\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @members }\n end\n end",
"def create\n @members_client = MembersClient.new(members_client_params)\n\n respond_to do |format|\n if @members_client.save\n format.html { redirect_to @members_client, notice: 'Members client was successfully created.' }\n format.json { render :show, status: :created, location: @members_client }\n else\n format.html { render :new }\n format.json { render json: @members_client.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(member_params)\n respond_to do |format|\n if @member.save\n format.html { redirect_to @member, notice: 'Profile created.' }\n else\n format.html { render :new }\n end\n end\n end",
"def create\n @member = Member.find(params[:member_id])\n respond_with do |format|\n if @member.update_attributes(:registered => true)\n Log.make(session[:mem_id], {:member => @member.id, :action => :register})\n format.html { redirect_to member_register_path(@member.id, 1) }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n\t\t@room_member = RoomLinkMember.new(room_member_params)\n\t\t@room_member.room = @room\n\n\t\trespond_to do |format|\n\t\t\tif @room_member.save\n\t\t\t\tback_page = room_members_url\n\t\t\t\tback_page = URI(request.referer).path if params[:back]\n\t\t\t\tback_page = params[:room_member][:redirect] unless params[:room_member][:redirect].empty?\n\t\t\t\tformat.html { redirect_to back_page, notice: 'Member was successfully created.' }\n\t\t\telse\n\t\t\t\tformat.html { render :new }\n\t\t\t\tformat.json { render json: @room_member.errors, status: :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def create\n @membership = Membership.new(params[:membership])\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership, notice: 'Membership was successfully created.' }\n format.json { render json: @membership, status: :created, location: @membership }\n else\n format.html { render action: \"new\" }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @member = Member.new\n user = @member.build_user\n @roles = Role.find(:all)\n \n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @member }\n end\n end",
"def member_params\n params.require(:member).permit(:name, :email, :location_id, :plan_id, :status)\n end",
"def member_params\n params.require(:member).permit(:name, :address, :phone)\n end",
"def add_members(_members)\n _members.each do |_user_id|\n user_relationships.where(user_id: _user_id).first_or_create!(accepted_at: Time.current)\n end\n end",
"def member_params\n params.require(:member).permit(:name, :email, :password, :password_confirmation)\n end",
"def member_params\n params.require(:member).permit(:email, :name, :password, :admin)\n end",
"def member_params\n params.require(:member).permit(:first_name, :last_name, :email, :phone_number)\n end",
"def new\n @member = Member.new\n user = @member.build_user\n @roles = Role.find(:all)\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @member }\n end\n end",
"def new\n @member = Member.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @member }\n end\n end",
"def new\n @member = Member.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @member }\n end\n end",
"def new\n @member = Member.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @member }\n end\n end",
"def new\n @member = Member.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @member }\n end\n end",
"def new\n @member = Member.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @member }\n end\n end",
"def new\n @member = Member.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @member }\n end\n end",
"def new\n @member = Member.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @member }\n end\n end",
"def new\n @member = Member.new\n \n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @member }\n end\n end",
"def create\n @member = Member.new(member_params)\n #@member.card_id = SecureRandom.uuid\n @member.magma_coins = 0\n add_abo_types_to_member(@member)\n respond_to do |format|\n if @member.save\n format.html { redirect_to current_user.present? ? @member : members_path, notice: t('flash.notice.creating_member') }\n format.json { render :show, status: :created, location: @member }\n else\n format.html { render :new, alert: t('flash.alert.creating_member') }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(params[:member])\n\n respond_to do |format|\n if @member.save\n flash[:notice] = 'Member was successfully created.'\n format.html { redirect_to(@member) }\n format.xml { render :xml => @member, :status => :created, :location => @member }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @membership = Membership.new(membership_params)\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to groups_path, notice: 'User was successfully added to group.' }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @member = Member.new(params[:member])\n @member.new = false\n\n respond_to do |format|\n if @member.save\n flash[:notice] = 'Member was successfully created.'\n format.html { redirect_to members_url(@member) }\n format.xml { head :created, :location => member_url(@member) }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @member.errors.to_xml }\n end\n end\n end",
"def create\n @membership = Membership.new(membership_params)\n\n respond_to do |format|\n if @membership.save\n format.html { redirect_to @membership, notice: \"Membership was successfully created.\" }\n format.json { render :show, status: :created, location: @membership }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bulk_create_team_members(body:)\n new_api_call_builder\n .request(new_request_builder(HttpMethodEnum::POST,\n '/v2/team-members/bulk-create',\n 'default')\n .header_param(new_parameter('application/json', key: 'Content-Type'))\n .body_param(new_parameter(body))\n .header_param(new_parameter('application/json', key: 'accept'))\n .body_serializer(proc do |param| param.to_json unless param.nil? end)\n .auth(Single.new('global')))\n .response(new_response_handler\n .deserializer(APIHelper.method(:json_deserialize))\n .is_api_response(true)\n .convertor(ApiResponse.method(:create)))\n .execute\n end",
"def create\n @member = Member.new(params[:member])\n\n if @member.save\n flash[:notice] = 'Member was successfully created.'\n redirect_to about_path(@member.url)\n else\n render :action => \"new\"\n end\n end",
"def create\n @team_member = TeamMember.new(team_member_params)\n\n respond_to do |format|\n if @team_member.save\n format.html { redirect_to @team_member, notice: 'Team member was successfully created.' }\n format.json { render :show, status: :created, location: @team_member }\n else\n format.html { render :new }\n format.json { render json: @team_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def list_members\n HTTP.headers(:accept => @@accept, \"content-type\" => @@content_type).basic_auth(:user => ENV[\"API_USERNAME\"], :pass => ENV[\"API_PASSWORD\"])\n .get(\"#{@@base_url}/users/#{self.guid}/members\").parse[\"members\"]\n end",
"def create\n @team_member = TeamMember.new(team_member_params)\n\n respond_to do |format|\n if @team_member.save\n format.html { redirect_to @team_member, notice: \"Team member was successfully created.\" }\n format.json { render :show, status: :created, location: @team_member }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @team_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def member_params\n params.require(:member).permit(:user_name, :rank_id, :activity_status_id)\n end",
"def create\n @group_member = GroupMember.new(group_member_params(params)) \n if(@group_member.save)\n render json { head :no_content }\n else\n render json: { errors: @group_member.errors.full_messages, status: :unprocessable_entity }\n end\n end",
"def members\n return @members if @members\n @members = Client.get(\"/organizations/#{id}/members/all\").json_into(Member)\n end",
"def create\n @member = Member.new(params[:member])\n respond_to do |format|\n if @member.save\n flash[:notice] = 'El socio se guardo con exito.'\n format.html { redirect_to(members_path) }\n format.xml { render :xml => @member, :status => :created, :location => @member }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @beneficiaire = Beneficiaire.find(params[:beneficiaire_id])\n @member = Member.new(member_params)\n\n respond_to do |format|\n if @member.save\n format.html { redirect_to @beneficiaire, notice: 'Member was successfully created.' }\n format.json { render :show, status: :created, location: @member }\n else\n format.html {redirect_to @beneficiaire, error: 'Member was not successfully created!' }\n format.json { render json: @beneficiaire.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @elder_member = ElderMember.new(elder_member_params)\n\n respond_to do |format|\n if @elder_member.save\n format.html { redirect_to @elder_member, notice: 'Elder member was successfully created.' }\n format.json { render action: 'show', status: :created, location: @elder_member }\n else\n format.html { render action: 'new' }\n format.json { render json: @elder_member.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
[
"0.6734318",
"0.6707801",
"0.66615456",
"0.66511947",
"0.6612481",
"0.6595865",
"0.6571146",
"0.6571146",
"0.6571146",
"0.6569636",
"0.65571123",
"0.65534073",
"0.6552213",
"0.6539384",
"0.6535769",
"0.6534659",
"0.6526704",
"0.6526704",
"0.6526704",
"0.6526704",
"0.6507443",
"0.6491895",
"0.64855516",
"0.6444056",
"0.6438115",
"0.6432237",
"0.6381778",
"0.63506615",
"0.633389",
"0.6320233",
"0.63125044",
"0.6296577",
"0.6285939",
"0.6260866",
"0.6243256",
"0.62419695",
"0.6235628",
"0.6230964",
"0.6221535",
"0.6206678",
"0.61989975",
"0.6198766",
"0.6195274",
"0.61692333",
"0.61499345",
"0.61461765",
"0.61322707",
"0.6128204",
"0.61243147",
"0.610482",
"0.60986006",
"0.60858136",
"0.6081078",
"0.60711473",
"0.60711473",
"0.60711473",
"0.606397",
"0.60610056",
"0.60574186",
"0.6048943",
"0.6048343",
"0.60453993",
"0.6034205",
"0.6029672",
"0.6001707",
"0.5979131",
"0.5978772",
"0.597445",
"0.5967211",
"0.59661597",
"0.5964004",
"0.5942135",
"0.59390485",
"0.593679",
"0.5936454",
"0.59359664",
"0.59253806",
"0.59253806",
"0.59253806",
"0.59253806",
"0.59253806",
"0.59253806",
"0.59253806",
"0.5922752",
"0.59159386",
"0.59106994",
"0.5899083",
"0.58947736",
"0.58701307",
"0.5845734",
"0.5842589",
"0.5832748",
"0.58321124",
"0.58289725",
"0.5827997",
"0.581858",
"0.580515",
"0.57962",
"0.57887846",
"0.57838494"
] |
0.6686722
|
2
|
PATCH/PUT /members/1 PATCH/PUT /members/1.json
|
def update
respond_to do |format|
if @member.update(member_params)
format.html { redirect_to space_member_url(@space, @member), notice: 'Member was successfully updated.' }
format.json { render :show, status: :ok, location: [@space, @member] }
else
format.html { render :edit }
format.json { render json: @member.errors, status: :unprocessable_entity }
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update\n # byebug \n respond_to do |format|\n if self.current_member && self.current_member.id == params[:id].to_i\n if @member.update(member_params)\n format.json { render :show, status: :ok, location: @member }\n else\n return api_error(status: :unprocessable_entity, message: @member.errors)\n end\n else\n return api_error(status: 401, message: '没有操作权限')\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(update_params)\n format.html { redirect_to @member }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\tif !checkme? then return end\n\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update!(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: \"Member was successfully updated.\" }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n params.require(:member).permit(:name)\n if @member.update(member_params)\n format.html { redirect_to @member, notice: '更新しました' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to admin_member_path(@member), notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n unless @member.err\n @member.get_member_uuid\n end\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n unless @member.err\n @member.get_member_uuid\n end\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n @uplines = Member.where.not(id: @member.self_and_descendants.collect(&:id)).order(\"fullname\")\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @creating_member = false\n\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'El miembro ha sido actualizado' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member == current_member && @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member updated.' }\n else\n format.html { render :edit }\n end\n end\n end",
"def update!(**args)\n @members = args[:members] if args.key?(:members)\n @resource = args[:resource] if args.key?(:resource)\n @resource_type = args[:resource_type] if args.key?(:resource_type)\n @role = args[:role] if args.key?(:role)\n end",
"def update\n respond_to do |format|\n if @member == current_member && @member.update(member_params)\n format.html { redirect_to @member, notice: 'Profile updated.' }\n else\n format.html { render :edit }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @attend, notice: 'Attend was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @members = args[:members] if args.key?(:members)\n @role = args[:role] if args.key?(:role)\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to(@member, :notice => 'Member was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to(@member, :notice => 'Member was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update(uid, params, membership)\n data = {\n initials: (params[4].nil? ? params[5][0] : params[4].tr('^a-zA-Z', '')),\n email: (params[3].nil? ? 'unknown@nieuwedelft.nl.invalid' : params[3]),\n gender: params[9] == 'Vrouw' ? 'F' : 'M',\n phone: params[14],\n mobile: params[2],\n phone_parents: params[24],\n address: [params[10], params[11], params[12]].join(' '),\n membership: membership,\n }\n begin\n unless params[15].nil?\n data[:dateofbirth] = Date.strptime(params[15], '%d-%m-%Y').strftime('%Y-%m-%d')\n end\n rescue\n $problems.write \"#{$index}, #{data[:firstname]} #{data[:lastname]}, Birthdate ignored\\n\"\n end\n patch(\"https://people.i.bolkhuis.nl/persons/#{uid}\", data)\n\n # Send payload to operculum\n put(\"https://operculum.i.bolkhuis.nl/person/#{uid}\", {\n nickname: params[8],\n study: params[16],\n alive: params[17].nil?,\n inauguration: params[25],\n resignation_letter: params[26],\n resignation: params[27],\n })\nend",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n flash[:notice] = 'Member was successfully updated.'\n format.html { redirect_to '/members/myindex' }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update_current_logged_in_user(args = {}) \n put(\"/users.json/current\", args)\nend",
"def update_members\n unless self.list_members.blank?\n #create new members\n self.list_members.each do |api_member|\n member_params = {}\n api_member.each_pair do |key, value|\n unless key == \"id\"\n if Member.attribute_names.include? key\n member_params[key] = value\n end\n end\n end\n #member already exists\n temp = Member.find_by guid: member_params[\"guid\"]\n if !!temp\n temp.attributes = member_params\n if temp.valid? \n temp.save\n else\n return \"problem updating existing member\"\n end\n else\n member = Member.new(member_params)\n if member.valid?\n member.save\n else\n return \"problem with member params\"\n end\n end\n #delete denied members\n if api_member[\"connection_status\"] != \"CONNECTED\"\n Member.find_by(guid: member_params[\"guid\"]).delete\n Member.delete_member(self.guid, member_params[\"guid\"])\n end\n end\n end\n end",
"def update\n respond_to do |format|\n if @members_client.update(members_client_params)\n format.html { redirect_to @members_client, notice: 'Members client was successfully updated.' }\n format.json { render :show, status: :ok, location: @members_client }\n else\n format.html { render :edit }\n format.json { render json: @members_client.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @user = User.find(params[:id])\n\n respond_to do |format|\n if @user.update_attributes(params[:user])\n format.html { redirect_to member_path(@user), notice: 'User was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to beneficiaire_member_path, notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to({ action: :show, challenge_id: params[:challenge_id], id: @member.id}, notice: 'Member was successfully updated.' )}\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @hack_member.update(hack_member_params)\n format.html { redirect_to @hack_member, notice: 'Hack member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @hack_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @member_type = args[:member_type] if args.key?(:member_type)\n @person_id = args[:person_id] if args.key?(:person_id)\n end",
"def update\n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n \n add_plan_to_user_if_specified!\n format.html { redirect_to(@member, :notice => 'Member was successfully updated.') }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n addMembers\n respond_to do |format|\n if @family.update(family_params)\n format.html { redirect_to @family, notice: 'Family was successfully updated.' }\n format.json { render :show, status: :ok, location: @family }\n else\n format.html { render :edit }\n format.json { render json: @family.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @member.update(member_params)\n logger.info(\"User #{current_user.email} updated Member '#{@member.first_name} #{@member.last_name}' in properties \n '#{@member.audits.last.audited_changes}' on #{@member.updated_at}\")\n format.html { redirect_to organization_path(@organization), notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @organization }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n respond_to do |format|\n if @member.update_attributes(params[:member])\n flash[:notice] = 'Member was successfully updated.'\n format.html { redirect_to member_url(@member) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @member.errors.to_xml }\n end\n end\n end",
"def update\n respond_to do |format|\n if !params[:roles].include?('president') && @member.has_role?(:president) && !Tenant.current.has_presidents\n format.html { redirect_to member_path(@member), notice: 'Please select other user as President.' }\n elsif @member.update(member_params)\n remove_roles\n add_roles(params[:roles])\n format.html { redirect_to member_path(@member), notice: 'Member was successfully updated.' }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n @member.new = false\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n flash[:notice] = 'Member was successfully updated.'\n format.html { redirect_to members_url }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @member.errors.to_xml }\n end\n end\n end",
"def update\n @oc_member = OcMember.find(params[:id])\n\n respond_to do |format|\n if @oc_member.update_attributes(params[:oc_member])\n format.html { redirect_to @oc_member, notice: 'Oc member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @oc_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @group_member = GroupMember.find(params[:id])\n\n respond_to do |format|\n if @group_member.update_attributes(params[:group_member])\n format.html { redirect_to @group_member, notice: 'Group member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: { errors: @group_member.errors, status: :unprocessable_entity }}\n end\n end\n end",
"def update\n @family_member = FamilyMember.find(params[:id])\n\n respond_to do |format|\n if @family_member.update_attributes(params[:family_member])\n format.html { redirect_to @family_member, notice: 'Family member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @family_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @member, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n @roles = Role.find(:all)\n\n\t\tif params[:commit] == \"Update Member\"\n\t\t\tchecked_roles = []\n\t\t\tchecked_params = params[:role_list] || []\n\t\t\t\tfor check_box_id in checked_params\n\t\t\t\t\trole = Role.find(check_box_id)\n\t\t\t\tif not @member.user.roles.include?(role)\n\t\t\t\t\t@member.user.roles << role\n\t\t\t\tend\n\t\t\tchecked_roles << role\n\t\t\tend\n\t\t\tmissing_roles = @roles - checked_roles\n\t\t\tfor role in missing_roles\n\t\t\t\tif @member.user.roles.include?(role)\n\t\t\t\t@member.user.roles.delete(role)\n\t\t\t\tend\n\t\t\tend\n\t\tend\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, :notice => 'Member was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @family_member = FamilyMember.find(params[:id])\n\n respond_to do |format|\n if @family_member.update_attributes(family_member_params)\n format.html { redirect_to @family_member, notice: 'Family member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @family_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n flash[:notice] = 'Member Successfully updated' if @member.update_attributes! params[:member]\n respond_with @project, @member\n end",
"def update\n # @client = Client.find(params[:client_id])\n # @group_member = GroupMember.where(:id => params[:id]).where(:client_id => params[:client_id])\n \n respond_to do |format|\n if @group_member.update(group_member_params)\n format.html { redirect_to client_group_member_path(@client,@group_member), notice: 'Group member was successfully updated.' }\n format.json { render :show, status: :ok, location: @group_member }\n else\n format.html { render :edit }\n format.json { render json: @group_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @aiit_member = AiitMember.find(params[:id])\n\n respond_to do |format|\n if @aiit_member.update_attributes(params[:aiit_member])\n format.html { redirect_to @aiit_member, notice: 'Aiit member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @aiit_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\t\t@member = Member.find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tif @member.update_attributes(params[:member])\n\t\t\t\tformat.html { redirect_to(@member, :notice => 'Member was successfully updated.') }\n\t\t\t\tformat.xml\t{ head :ok }\n\t\t\telse\n\t\t\t\tformat.html { render :action => \"edit\" }\n\t\t\t\tformat.xml\t{ render :xml => @member.errors, :status => :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def update\n render json: User.update(params[\"id\"], params[\"user\"])\n end",
"def update\n respond_to do |format|\n if @elder_member.update(elder_member_params)\n format.html { redirect_to @elder_member, notice: 'Elder member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @elder_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member_type = MemberType.find(params[:id])\n\n respond_to do |format|\n if @member_type.update_attributes(params[:member_type])\n format.html { redirect_to @member_type, notice: 'Member type was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @who_member = WhoMember.find(params[:id])\n\n respond_to do |format|\n if @who_member.update_attributes(params[:who_member])\n format.html { redirect_to(@who_member, :notice => 'WhoMember was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @who_member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @membership ||= Membership.find(params[:id])\n\n respond_to do |format|\n if @membership.update_attributes(params[:membership])\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @membership = Membership.find(params[:id])\n\n respond_to do |format|\n if @membership.update_attributes(params[:membership])\n format.html { redirect_to @membership, :notice => 'Membership was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @membership.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @role = args[:role] unless args[:role].nil?\n @members = args[:members] unless args[:members].nil?\n end",
"def update\n respond_to do |format|\n if @member_status.update(member_status_params)\n format.html { redirect_to @member_status, notice: 'Member status was successfully updated.' }\n format.json { render :show, status: :ok, location: @member_status }\n else\n format.html { render :edit }\n format.json { render json: @member_status.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @meeting_member = MeetingMember.find(params[:id])\n\n respond_to do |format|\n if @meeting_member.update_attributes(params[:meeting_member])\n format.html { redirect_to @meeting_member, :notice => 'Meeting member was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @meeting_member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @role = args[:role] if args.key?(:role)\n @members = args[:members] if args.key?(:members)\n end",
"def test_update_member_basic_success\n\n client = create_mock_client\n refute_nil client, \"Client object couldn't be created.\"\n\n stub_request(:patch, mock_uri('Groups', '17', 'Members', '5'))\n .to_return(status: 202, body: { 'Success' => true,\n 'Message' => \"Operation succeeded\",\n 'ApiId' => API_ID }.to_json)\n\n status, = client.group.update_member(17, 5, '91XXXXXXXXXX')\n refute_nil status, \"No status object returned.\"\n assert status.success, \"Status did not indicate success: \" + status.message.to_s\n\n end",
"def test_should_update_group_user_via_API_JSON\r\n # lookup user's membership\r\n get \"memberships/find.json?api_key=testapikey&user_id=4&group_id=1\"\r\n membership = JSON.parse(response.body)\r\n membership_id = membership['id']\r\n assert membership_id == 3, 'Incorrect membership id'\r\n assert membership['role_id'] == Role.find_by_rolename('user').id, 'Incorrect role id'\r\n \r\n # promote user to group admin\r\n put \"/memberships/#{membership_id}.xml\", :api_key => 'testapikey',\r\n :membership => {:user_id => 4,\r\n :group_id => 1,\r\n :role_id => Role.find_by_rolename('group_admin') }\r\n assert_response :success\r\n end",
"def update\n if current_member.can_admin_members?\n # this if statement allows devise to accept record when password is not filled in\n if params[:member][:password].blank?\n params[:member].delete(:password)\n params[:member].delete(:password_confirmation)\n end\n \n @member = Member.find(params[:id])\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n else\n render_forbidden\n end\n end",
"def update\n add_abo_types_to_member(@member)\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to members_url, notice: t('flash.notice.updating_member') }\n format.json { render :show, status: :ok, location: @member }\n else\n format.html { render :edit, alert: t('flash.alert.updating_member') }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member_info = MemberInfo.find(params[:id])\n\n respond_to do |format|\n if @member_info.update_attributes(params[:member_info])\n format.html { redirect_to(@member_info, :notice => 'MemberInfo was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @member_info.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n if request.content_type == \"application/json\"\n # .update is like a \"update people set ...\" in sql\n if @person.update(person_params)\n render json: @person\n else\n render json: @person.errors, status: :not_found\n end\n else\n render status: :bad_request\n end\n end",
"def update\n @member = Member.find(params[:id])\n respond_to do |format|\n if @member.update_attributes(params[:member])\n flash[:notice] = \"Los datos del socio #{@member.name} #{@member.last_name} se actualizaron satisfactoriamente\"\n format.html { redirect_to(members_path) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @team_member.update(team_member_params)\n format.html { redirect_to @team_member, notice: 'Team member was successfully updated.' }\n format.json { render :show, status: :ok, location: @team_member }\n else\n format.html { render :edit }\n format.json { render json: @team_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @team_member.update(team_member_params)\n format.html { redirect_to @team_member, notice: 'Team member was successfully updated.' }\n format.json { render :show, status: :ok, location: @team_member }\n else\n format.html { render :edit }\n format.json { render json: @team_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @member = Member.find(params[:id])\n\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n Emailer.welcome_email(@member).deliver\n format.html { redirect_to(@member, :notice => 'Member was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @member.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @group_member.update(group_member_params)\n format.html { redirect_to @group_member, notice: 'Group member was successfully updated.' }\n format.json { render :show, status: :ok, location: @group_member }\n else\n format.html { render :edit }\n format.json { render json: @group_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @user.update(user_params)\n members = Member.all\n available = false\n members.each do |current_member|\n if current_member.user_id == @user.id\n available = true\n end\n end\n if available == false && @user.role != TEACHER\n @member = Member.new\n @member.user_id = @user.id\n @member.project_id = session[:selected_project_id]\n @member.is_enabled = true\n @member.section_number = params['section_number']\n @member.save\n end\n if @user.role != TEACHER\n member = Member.find_by(user_id: @user.id, project_id: get_selected_project)\n member.section_number = params['section_number']\n member.save\n end\n \n if @user.role == TEACHER\n format.html { redirect_to users_teachers_path, notice: \"#{@user.first_name} was successfully updated.\"}\n else\n format.html { redirect_to users_path, notice: \"#{@user.first_name} was successfully updated.\"}\n format.json { head :no_content }\n end\n else\n format.html { render action: 'edit' }\n format.json { render json: @user.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @team_member.update(team_member_params)\n format.html { redirect_to @team_member, notice: \"Team member was successfully updated.\" }\n format.json { render :show, status: :ok, location: @team_member }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @team_member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update \n user = User.find(params[:id])\n # byebug\n user.update(user_params)\n\n render json: user\n end",
"def update\n respond_to do |format|\n if @member_class.update(member_class_params)\n format.html { redirect_to @member_class, notice: 'Member class was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @member_class.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_tenant_circle(args = {}) \n put(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def update\n respond_to do |format|\n if @member.update(member_params)\n @member.avatar.attach(member_params[:avatar]) unless member_params[:avatar].nil?\n format.html { redirect_to my_profile_path, notice: 'Member was successfully updated.' }\n format.json {}\n else\n format.html { render :edit }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @membership.update(membership_params)\n format.html { redirect_to @membership, notice: 'Membership was successfully updated.' }\n format.json { render :show, status: :ok, location: @membership }\n else\n format.html { render :edit }\n format.json { render json: @membership.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n render json: Users.update(params[\"id\"], params[\"user\"])\n end",
"def update\n params[:member].delete(:site_user) if params[:member][:site_user].blank?\n\n respond_to do |format|\n if @member.update(member_params)\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch!\n request! :patch\n end",
"def update_users_password(args = {}) \n put(\"/users.json/backoffice/#{args[:userId]}/password/#{args[:password]}\", args)\nend",
"def update_users_password(args = {}) \n put(\"/users.json/backoffice/#{args[:userId]}/password/#{args[:password]}\", args)\nend",
"def update\n @member = Member.find(params[:id])\n\n if @member.vend_total.nil?\n @member.vend_total = 0\n end\n\n if @member.vend_credits.nil?\n @member.vend_credits = 1\n end\n \n if @member.door_count.nil?\n @member.door_count = 0\n end\n \n\n raise CanCan::AccessDenied if cannot? :edit, @member\n\n respond_to do |format|\n if @member.update_attributes(params[:member])\n format.html { redirect_to @member, notice: 'Member was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update(args)\n builder.update_rest(type, ref, args, username, password)\n self.elements(true)\n end"
] |
[
"0.6825534",
"0.66732514",
"0.66082865",
"0.65920675",
"0.6553189",
"0.65405244",
"0.6517594",
"0.6517594",
"0.6517594",
"0.6517594",
"0.6517594",
"0.65155286",
"0.6492895",
"0.64920187",
"0.64920187",
"0.64920187",
"0.64920187",
"0.64920187",
"0.64920187",
"0.64920187",
"0.64920187",
"0.64920187",
"0.64834744",
"0.6440318",
"0.64174134",
"0.64174134",
"0.63095",
"0.63092166",
"0.62325466",
"0.6198135",
"0.617479",
"0.6157374",
"0.61482155",
"0.6137291",
"0.6137291",
"0.6134158",
"0.61265415",
"0.6120516",
"0.6110899",
"0.6109405",
"0.6108315",
"0.60946643",
"0.60684085",
"0.6068088",
"0.60543853",
"0.60441065",
"0.6038961",
"0.6037597",
"0.603631",
"0.59974957",
"0.5996359",
"0.59951514",
"0.5987309",
"0.5976677",
"0.59608686",
"0.59501487",
"0.5948939",
"0.5948619",
"0.594355",
"0.5932146",
"0.5922127",
"0.5921985",
"0.59175426",
"0.5893945",
"0.5891664",
"0.5890771",
"0.58710206",
"0.5868276",
"0.58570904",
"0.58522135",
"0.58484703",
"0.58366644",
"0.5820812",
"0.58150953",
"0.5808038",
"0.58039033",
"0.58008003",
"0.57847345",
"0.57803094",
"0.57803094",
"0.57752293",
"0.5768873",
"0.57651156",
"0.57603145",
"0.5743582",
"0.57424825",
"0.5734222",
"0.5733764",
"0.57182676",
"0.57182676",
"0.57182676",
"0.57182676",
"0.57182676",
"0.57164717",
"0.5713805",
"0.57119566",
"0.5707116",
"0.5707116",
"0.57058537",
"0.5705188"
] |
0.61127734
|
38
|
DELETE /members/1 DELETE /members/1.json
|
def destroy
@member.destroy
respond_to do |format|
format.html { redirect_to space_members_url(@space), notice: 'Member was successfully destroyed.' }
format.json { head :no_content }
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n \n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to(members_url) }\n format.json { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n\tif !checkadmin? then return end\n\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to admin_member_members_path, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy!\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'El miembro ha sido eliminado' }\n format.json { head :no_content }\n end\n end",
"def destroy \n @oc_member = OcMember.find(params[:id])\n @oc_member.destroy\n\n respond_to do |format|\n format.html { redirect_to oc_members_url }\n format.json { head :no_content }\n end\n end",
"def delete(*args)\n arguments(args, required: [:org_name, :user])\n\n delete_request(\"/orgs/#{arguments.org_name}/members/#{arguments.user}\",\n arguments.params)\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n \n \n respond_to do |format|\n format.html { redirect_to(members_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: '削除しました' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html do\n redirect_to members_url,\n notice: 'Profile was successfully deleted.'\n end\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html do\n redirect_to members_url,\n notice: 'Member was successfully destroyed.'\n end\n format.json { head :no_content }\n end\n end",
"def destroy\n session[:member_id] = nil\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url }\n format.xml { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to(members_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to(members_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to(members_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to(members_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @aiit_member = AiitMember.find(params[:id])\n @aiit_member.destroy\n\n respond_to do |format|\n format.html { redirect_to aiit_members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n\n respond_to do |format|\n flash[:notice] = \"Destroyed user\"\n format.html { redirect_to(members_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @member.destroy\n\n respond_to do |format|\n flash[:notice] = \"Destroyed user\"\n format.html { redirect_to(members_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n raise CanCan::AccessDenied if cannot? :delete, @member\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @who_member = WhoMember.find(params[:id])\n @who_member.destroy\n\n respond_to do |format|\n format.html { redirect_to(who_members_url) }\n format.xml { head :ok }\n format.json { head :ok }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.deleted = true\n @member.save\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.xml { head :ok }\n end\n end",
"def destroy\n @elder_member.destroy\n respond_to do |format|\n format.html { redirect_to elder_members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n\t\t@room.members.destroy(params[:id])\n\t\trespond_to do |format|\n\t\t\tback_page = room_members_url\n\t\t\tback_page = URI(request.referer).path if params[:back]\n\t\t\tback_page = params[:redirect] if params[:redirect]\n\t\t\tformat.html { redirect_to back_page, notice: 'Member was successfully destroyed.' }\n\t\t\tformat.json { head :no_content }\n\t\tend\n\tend",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to memberships_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to memberships_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @members_client.destroy\n respond_to do |format|\n format.html { redirect_to members_clients_url, notice: 'Members client was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy_member\n\n #@member = Member.find\n #@member.destroy\n respond_to do |format|\n format.html { redirect_to organizations_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find(params[:id])\n @member.destroy\n logger.info(\"#{Time.now} Se elimina el miembro ##{@member.id}!\")\n respond_to do |format|\n format.html { redirect_to(members_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n\t\t@member = Member.find(params[:id])\n\t\t@member.destroy\n\n\t\trespond_to do |format|\n\t\t\tformat.html { redirect_to(members_url) }\n\t\t\tformat.xml\t{ head :ok }\n\t\tend\n\tend",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to @user }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member = Member.find_by_url_or_id(params[:id])\n @member.destroy\n\n redirect_to(members_url)\n end",
"def destroy\n @dotsmember = Dotsmember.find(params[:id])\n @dotsmember.destroy\n\n respond_to do |format|\n format.html { redirect_to dotsmembers_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @hack_member.destroy\n respond_to do |format|\n format.html { redirect_to hack_members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_to attends_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership ||= Membership.find(params[:id])\n @membership.destroy\n\n respond_to do |format|\n format.html { redirect_to memberships_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to member_url(@membership.member), notice: 'Membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @clnmember = Clnmember.find(params[:id])\n @clnmember.destroy\n\n respond_to do |format|\n format.html { redirect_to clnmembers_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @group_member = GroupMember.find(params[:id])\n @group_member.destroy\n\n respond_to do |format|\n format.html { redirect_to group_members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @dc_member = DcMember.find(params[:id])\n @dc_member.destroy\n\n respond_to do |format|\n format.html { redirect_to dc_members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member_type = MemberType.find(params[:id])\n @member_type.destroy\n\n respond_to do |format|\n format.html { redirect_to member_types_url }\n format.json { head :no_content }\n end\n end",
"def delete\n sql = 'DELETE FROM members WHERE id = $1'\n values = [@id]\n SqlRunner.run(sql, values)\nend",
"def destroy\n @user = User.find(params[:id])\n @user.destroy\n\n respond_to do |format|\n format.html { redirect_to \"/members?is_approved=0\" }\n format.json { head :no_content }\n end\n \n end",
"def \n \n\n # ADMIN ONLY:\n # Deleting a Member\n # delete /members/:id\n def destroy\n # Maybe this shouldn't be allowed if member has transactions?\n # Since calculations are based on all transactions from the\n # beginning of time, deleting a member's transactions would\n # impact the other members' debts...\n Member.find(params[:id]).destroy\n flash[:success] = \"Deleted\"\n redirect_to members_path\n end",
"def destroy\n organization = @member.organization \n\n @member.destroy\n logger.info(\"User #{current_user.email} destroyed Member '#{@member.first_name} #{@member.last_name}' on #{@member.updated_at}\")\n respond_to do |format|\n format.html { redirect_to organization, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete_member path\n rewrite_members member_paths.delete(path)\n end",
"def destroy\n @member_info = MemberInfo.find(params[:id])\n @member_info.destroy\n\n respond_to do |format|\n format.html { redirect_to(member_infos_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to memberships_url, notice: \"Membership was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to memberships_url, notice: 'Membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n if !current_member.the_admin?\n redirect_to \"/\", notice: \"Access denied\"\n return\n end\n\n @member.destroy unless @member.core_member?\n respond_to do |format|\n format.html { redirect_to members_url, notice: \"Member was#{@member.core_member? ? ' not' : ''} successfully destroyed.\"}\n format.json { head :no_content }\n end\n end",
"def destroy\n @crewmember.destroy\n respond_to do |format|\n format.html { redirect_to crewmembers_url, notice: 'Crewmember was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.abo_types.delete_all\n respond_to do |format|\n if @member.destroy\n format.html { redirect_to members_url, notice: t('flash.notice.deleting_member') }\n format.json { head :no_content }\n else\n format.html { render :show, alert: t('flash.alert.deleting_member') }\n format.json { render json: @member.errors, status: :unprocessable_entity }\n end\n end\n end",
"def destroy\n @member = Member.find(params[:member_id])\n @sign = Sign.find(params[:id])\n @sign.destroy\n respond_to do |format|\n format.html { redirect_to member_signs_url( @member ) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @project_member.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @member.destroy\n respond_to do |format|\n format.html { redirect_back fallback_location: root_path, notice: \"Member was successfully destroyed.\" }\n format.json { head :no_content }\n format.js\n end\n end",
"def destroy\n #@member = Member.find(params[:id])\n @member.destroy\n\n redirect_back_or_default(root_path)\n end",
"def remove_member_from_list(user, list, member_id)\n delete(\"/#{user}/#{list}/members.json?id=#{member_id}\")\n end",
"def destroy\n @family_member = FamilyMember.find(params[:id])\n @family_member.destroy\n\n respond_to do |format|\n format.html { redirect_to family_members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @family_member = FamilyMember.find(params[:id])\n @family_member.destroy\n\n respond_to do |format|\n format.html { redirect_to family_members_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n if @member.email == \"admin@admin.com\"\n redirect_to logged_in_user, notice: \"Cannot Delete SuperUser.\"\n else\n Booking.where(member_id: @member.id).destroy_all\n @member.destroy\n respond_to do |format|\n format.html { redirect_to members_url, notice: 'Member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end\n end",
"def remove_member(id, user)\n client.delete(\"#{path}/#{id}/members\", user)\n end",
"def delete\n render json: User.delete(params[\"id\"])\n end",
"def destroy\n @group_member.destroy\n respond_to do |format|\n format.html { redirect_to client_group_members_url, notice: 'Group member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @member_status.destroy\n respond_to do |format|\n format.html { redirect_to member_statuses_url, notice: 'Member status was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @membership.destroy\n respond_to do |format|\n format.html { redirect_to groups_path, notice: 'Membership was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @meeting_member = MeetingMember.find(params[:id])\n @meeting_member.destroy\n\n respond_to do |format|\n format.html { redirect_to meeting_members_url }\n format.json { head :ok }\n end\n end",
"def delete_tenant_circle(args = {}) \n delete(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def destroy\n User.destroy(params[:id])\n flash[:notice] = \"Deleted member!\"\n redirect_to :action => :index\n end",
"def destroy\n User.destroy(params[:id])\n flash[:notice] = \"Deleted member!\"\n redirect_to :action => :index\n end",
"def destroy\n @image_member = ImageMember.find(params[:id])\n @image_member.destroy\n\n respond_to do |format|\n format.html { redirect_to image_members_url }\n format.json { head :no_content }\n end\n end",
"def del_member(_user_id)\n update!(del_members: [_user_id])\n end",
"def destroy\n if current_member.can_admin_admins?\n @member = Member.find(params[:id])\n @member.destroy\n\n respond_to do |format|\n format.html { redirect_to members_url }\n format.json { head :ok }\n end\n else\n render_forbidden\n end\n end",
"def destroy\n @member_class.destroy\n respond_to do |format|\n format.html { redirect_to member_classes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @family_member = User.find(params[:id])\n @family_member.destroy\n respond_to do |format|\n format.html { redirect_to familymembers_path, notice: 'Family member was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete\n render json: Users.delete(params[\"id\"])\n end"
] |
[
"0.76810235",
"0.7641482",
"0.7641482",
"0.76110274",
"0.76110274",
"0.7567863",
"0.7567863",
"0.7557461",
"0.7545494",
"0.7545494",
"0.7545494",
"0.7545494",
"0.7545494",
"0.7545494",
"0.7545494",
"0.73533356",
"0.7306361",
"0.7306361",
"0.7306361",
"0.7306361",
"0.7306361",
"0.7306361",
"0.7306361",
"0.7306361",
"0.7306361",
"0.7306361",
"0.7285102",
"0.7273715",
"0.72673005",
"0.72658414",
"0.72532946",
"0.7242179",
"0.7229291",
"0.7226216",
"0.7218416",
"0.719752",
"0.71951795",
"0.71767515",
"0.71767515",
"0.71767515",
"0.71767515",
"0.71489406",
"0.7142683",
"0.7142683",
"0.7120784",
"0.7075898",
"0.7069348",
"0.7054301",
"0.703464",
"0.7021046",
"0.7021046",
"0.6994502",
"0.69750124",
"0.6974544",
"0.6974188",
"0.6967686",
"0.6963345",
"0.6954128",
"0.6953548",
"0.69449246",
"0.6929638",
"0.69233143",
"0.68946254",
"0.68803453",
"0.68776536",
"0.6866163",
"0.68415755",
"0.6827112",
"0.68235826",
"0.6813723",
"0.6784357",
"0.67840856",
"0.6781284",
"0.67811644",
"0.6762894",
"0.67608774",
"0.6752463",
"0.6752435",
"0.6748311",
"0.6741069",
"0.67360204",
"0.6717048",
"0.6686093",
"0.6686093",
"0.6684497",
"0.66823447",
"0.6678768",
"0.6677306",
"0.6656677",
"0.6643223",
"0.6640349",
"0.6636488",
"0.66171527",
"0.66171527",
"0.6605767",
"0.6595474",
"0.65932226",
"0.6588253",
"0.6587859",
"0.65791637"
] |
0.6972323
|
55
|
Use callbacks to share common setup or constraints between actions.
|
def set_member
@member = @space.members.friendly.find(params[:id])
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def setup_handler\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def workflow\n end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup\n # override and do something appropriate\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def before_action \n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def setup_signals; end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def initialize(*args)\n super\n @action = :set\nend",
"def after_set_callback; end",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def around_hooks; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def duas1(action)\n action.call\n action.call\nend",
"def shared_action(name, &block)\n @controller.shared_actions[name] = block\n end",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] |
[
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576",
"0.53124547",
"0.529654",
"0.5296262",
"0.52952296",
"0.52600986",
"0.52442724",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.5232394",
"0.523231",
"0.5227454",
"0.52226824",
"0.52201617",
"0.5212327",
"0.52079266",
"0.52050185",
"0.51754695",
"0.51726824",
"0.51710224",
"0.5166172",
"0.5159343",
"0.51578903",
"0.51522785",
"0.5152022",
"0.51518047",
"0.51456624",
"0.51398855",
"0.5133759",
"0.5112076",
"0.5111866",
"0.5111866",
"0.5110294",
"0.5106169",
"0.509231",
"0.50873137",
"0.5081088",
"0.508059",
"0.50677156",
"0.50562143",
"0.5050554",
"0.50474834",
"0.50474834",
"0.5036181",
"0.5026331",
"0.5022976",
"0.5015441",
"0.50121695",
"0.5000944",
"0.5000019",
"0.4996878",
"0.4989888",
"0.4989888",
"0.49864885",
"0.49797225",
"0.49785787",
"0.4976161",
"0.49683493",
"0.4965126",
"0.4958034",
"0.49559742",
"0.4954353",
"0.49535993",
"0.4952725",
"0.49467874",
"0.49423352",
"0.49325448",
"0.49282882",
"0.49269363",
"0.49269104",
"0.49252945",
"0.4923091",
"0.49194667",
"0.49174926",
"0.49173003",
"0.49171105",
"0.4915879",
"0.49155936"
] |
0.0
|
-1
|
Never trust parameters from the scary internet, only allow the white list through.
|
def member_params
params.require(:member).permit(:name, :email, :location_id, :plan_id, :status)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def param_whitelist\n [:role, :title]\n end",
"def expected_permitted_parameter_names; end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def allowed_params\n params.require(:user).permit(:username, :email, :password, :password_confirmation)\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def user_params \n \tparams.require(:user).permit(:name, :email, :password, :password_confirmation)# preventing CSTR\n end",
"def user_params\n params.permit(:name, :phoneNumber, :address, :postalCode, :local, :link, :counter, :latitude, :longitude) \n end",
"def valid_params_request?; end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def whitelist_url_params\n params.require(:whitelist_url).permit(:domain)\n end",
"def allowed_params\n params.require(:allowed).permit(:email)\n end",
"def permitted_params\n []\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def query_param\n\t\tparams.permit(:first_name, :last_name, :phone)\n\tend",
"def strong_params\n params.require(:success_metric).permit(param_whitelist)\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def whitelisted_user_params\n params.require(:user).\n permit( :first_name, :last_name, :email,:password,:password_confirmation,:birthday,:gender)\n end",
"def user_params\n ActionController::Parameters.permit_all_parameters = true\n params.require(:user) #.permit(:name, :surname, :phone, :password, :email, :time_zone)\n end",
"def strong_params\n params.require(:metric_change).permit(param_whitelist)\n end",
"def safe_params\n params.require(:user).permit(:name)\n end",
"def get_params\n\t\treturn ActionController::Parameters.new(self.attributes).permit(\"account_id\", \"title\", \"category\", \"introduction\", \"tags\", \"segment_type\", \"visible\", \"status\", \"main_image\")\n\tend",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def check_params; true; end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def quote_params\n params.permit!\n end",
"def valid_params?; end",
"def paramunold_params\n params.require(:paramunold).permit!\n end",
"def user_params\n\t\tparams.permit(:nickname, :avatar, :description, :password, :gender, :birthday, :email, :phone, :qq_id, :wechat_id)\n\tend",
"def filtered_parameters; end",
"def user_params\n params.permit(\n \t:id,\n \t:email, \n \t:first_name, \n \t:last_name, \n \t:password, \n \t:confirm_token, \n \t:phone_number,\n \t:facebook_link,\n \t:car_model,\n \t:license_plate)\n end",
"def filtering_params\n params.permit(:email, :name)\n end",
"def check_params\n true\n end",
"def wx_public_params\n params.require(:wx_public).permit(:nickname, :manager, :alias)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def listing_params\n\t\tparams.permit(:address, :transit_info, :rules, :other_info, :lat, :lng)\n\tend",
"def social_account_params\n\t\t\tparams.require(:social_account).permit!\n\t\tend",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def url_params\n params.require(:url).permit(:short_url, :original_url, :clicks, :ip_addresses)\n end",
"def user_params\n params.require(:user).permit(:uri, :username, :password, :realname, :email, :publicvisible)\n end",
"def model_params\n\t\tparams.require(:manager).permit(\n\t :user_name,\n :password,\n :email,\n \t\t\t)\n\tend",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def college_whitelist_params\n params.require(:college_whitelist).permit(:status)\n end",
"def active_code_params\n params[:active_code].permit\n end",
"def filtering_params\n params.permit(:email)\n end",
"def valid_params(params)\n params.permit(:user_id, :photo_id, :originX, :originY, :width, :height)\n end",
"def ip_address_params\n\t\t\tparams.require(:ip_address).permit!\n end",
"def pull_request_params\n whitelist = [\n :url,\n :id,\n :html_url,\n :diff_url,\n :patch_url,\n :issue_url,\n :number,\n :state,\n :locked,\n :title\n ]\n params.require(:pull_request).permit(whitelist)\n end",
"def reserved_params\n params.require(:reserved).permit(:name, :email, :pax, :address, :KTP, :title)\n end",
"def post_params\n if current_user.admin? \n params.permit(:title, :body, :city, :country, :gps_location, :privacy, :visible, :latitude, :longitude, images: [], files: [])\n else \n params.permit(:title, :body, :city, :country, :gps_location, :privacy,:latitude, :longitude, images: [], files: [])\n end \n end",
"def list_params\n params.permit(:name)\n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def vineyard_params\n params.permit(:vineyard_name, :email, :website_url, :phone, :address, :city, :region, :postcode, :country, :specialty, :description, :pet_friendly, :holiday, :tours, :events, :family_friendly, :cover_image, :image_one, :image_two, :image_three, :image_four, :user_id, :base64)\n end",
"def available_activity_params\n # params.require(:available_activity).permit(:type,:geometry,:properties)\n whitelisted = ActionController::Parameters.new({\n type: params.require(:available_activity)[:type],\n geometry: params.require(:available_activity)[:geometry].try(:permit!).to_h,\n properties: params.require(:available_activity)[:properties].try(:permit!).to_h\n }).try(:permit!)\n end",
"def user_params\n params.permit(:name, :username, :email, :password, :img_url, :bg_url, :coinbank)\n end",
"def user_params_pub\n\t \tparams[:user].permit(:hruid)\n\t end",
"def user_params\n params.permit(:id, :email, :password, :nickname, :status, :avatar, :flat_picture, :flatsharing_id, :member,\n :user, :color, :solde)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def url_whitelist; end",
"def admin_social_network_params\n params.require(:social_network).permit!\n end",
"def filter_params\n params.require(:filters).permit(:letters)\n end",
"def origin_params\n params.permit(:country, :state, :city, :postal_code, :address, :description)\n end",
"def valid_params(params)\n params.permit(:login, :first_name, :last_name, \n :password, :password_confirmation)\n end",
"def sensitive_params=(params)\n @sensitive_params = params\n end",
"def permit_request_params\n params.permit(:address)\n end",
"def user_params\n # Ensure a user can't give themselves admin priveleges\n params.delete(:admin) if current_user.admin?\n params.require(:user).permit(:name, :email, :admin, :image)\n end",
"def secure_params\n params.require(:location).permit(:name)\n end",
"def strong_params\n params.require( :setting ).\n permit( :global_scan_limit, :per_user_scan_limit,\n :target_whitelist_patterns, :target_blacklist_patterns )\n end",
"def question_params\n params.require(:survey_question).permit(question_whitelist)\n end",
"def case_insensitive_params\n params.require(:case_insensitive).permit(:name)\n end",
"def empire_master_no_match_params\n params.require(:empire_master_no_match).permit(:uid, :last_name, :list, :search_date, :double, :source)\n end",
"def maintenance_request_params\n params[:maintenance_request].permit! #allow all parameters for now\n end",
"def unwanted_params\n params.require(:unwanted).permit(:title, :description, :image)\n end",
"def url_params\n params[:url].permit(:full)\n end",
"def backend_user_params\n params.permit!\n end",
"def filter_params\n\t\treturn params[:candidate].permit(:name_for_filter)\n\tend",
"def speed_measurement_params\n\n #fuckit, to lazy to deal with permit crap right now\n ActionController::Parameters.permit_all_parameters = true\n\n params[:speed_measurement]\n end",
"def user_params\n params.permit(:name, :age, :username, :display_photo, :password)\n end",
"def get_params\r\n #params.require(:article).permit(:title, :permalink, :content, :source_site, :introtext, :type_id, :order_by, :searchable, :created_by, :edited_by, :published_by, :published_on, :user_id)\r\n params.require(:article).permit!\r\n\r\n end",
"def pub_params\n params.require(:pub).permit(:name, :description, :phone, :email, :hidden, :city_id, :address)\n end",
"def pass_params\n params[:pass].permit(:name, :price, :description, :colour, :events)\n end",
"def droptraining_params\n params.permit(:training_id,:user_id, :utf8, :authenticity_token, :commit)\n end",
"def person_params\n # params whitelist does *not* include admin, sub, remember_token\n # TBD: share this whitelist with the list used by configuration_permitted_parameters\n # TBD: should current_password be on this list? -- for now, leaving off, since it seems to work without\n # NOTE: do not include 'admin' in this list!\n params.require(:person).permit(\n :name, \n :email, \n :description,\n :password, \n :password_confirmation\n )\n end",
"def parameter_params\n params.require(:parameter).permit(:name, :description, :param_code, :param_value, :active_from, :active_to)\n end"
] |
[
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",
"0.62894756",
"0.6283177",
"0.6242471",
"0.62382483",
"0.6217549",
"0.6214457",
"0.6209053",
"0.6193042",
"0.6177802",
"0.6174604",
"0.61714715",
"0.6161512",
"0.6151757",
"0.6150663",
"0.61461",
"0.61213595",
"0.611406",
"0.6106206",
"0.6105114",
"0.6089039",
"0.6081015",
"0.6071004",
"0.60620916",
"0.6019971",
"0.601788",
"0.6011056",
"0.6010898",
"0.6005122",
"0.6005122",
"0.6001556",
"0.6001049",
"0.59943926",
"0.5992201",
"0.59909594",
"0.5990628",
"0.5980841",
"0.59669393",
"0.59589154",
"0.5958826",
"0.5957911",
"0.5957385",
"0.5953072",
"0.59526145",
"0.5943361",
"0.59386164",
"0.59375334",
"0.59375334",
"0.5933856",
"0.59292704",
"0.59254247",
"0.5924164",
"0.59167904",
"0.59088355",
"0.5907542",
"0.59064597",
"0.5906243",
"0.5898226",
"0.589687",
"0.5896091",
"0.5894501",
"0.5894289",
"0.5891739",
"0.58860534",
"0.5882406",
"0.587974",
"0.58738774",
"0.5869024",
"0.58679986",
"0.5867561",
"0.5865932",
"0.5864461",
"0.58639693",
"0.58617616",
"0.5861436",
"0.5860451",
"0.58602303",
"0.5854586",
"0.58537364",
"0.5850427",
"0.5850199"
] |
0.0
|
-1
|
GET /loans or /loans.json
|
def index
@loans = Loan.all
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def loans\n url = \"#{LOANS_PATH}/pre-approved\"\n data = perform_get(url)\n data || {}\n end",
"def index\n @loans = Loan.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @loans }\n end\n end",
"def index\n render json: Loan.all\n end",
"def index_loans_for_bundle\n @bundles = Bundle.find(params[:id])\n\n respond_to do |format|\n format.html { render 'loans/index'}\n format.xml { render :xml => @bundles }\n end\n end",
"def index\n @losts = Lost.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @losts }\n end\n end",
"def show\n @loan = Loan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @loan }\n end\n end",
"def index\n @lophs = Loph.all\n respond_to do |format|\n format.html\n format.json { render json: @lophs}\n end\n end",
"def specific\n @state = State.find(params[:id])\n @loans = @state.loans.where(:purpose_id == params[:purpose_id])\n render json: { state: @state, loans: @loans }\n end",
"def list\n get('/')\n end",
"def index\n @laws = Law.sorted\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @laws }\n end\n end",
"def index\n @laws = Law.ordered_roots\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @laws }\n end\n end",
"def index\n @loans = @tool.loans.all\n end",
"def index\n @money = Money.all\n require 'net/http'\n require 'json'\n @url = 'https://api.coinmarketcap.com/v1/ticker/'\n @uri = URI(@url)\n @response = Net::HTTP.get(@uri)\n @lookup_money = JSON.parse(@response)\n end",
"def index\n @current_user = User.find(session[:user_id])\n \n @loans = Loan.all\n end",
"def index\n @loves = Love.all\n render json: @loves\n end",
"def index\n @litters = Litter.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @litters }\n end\n end",
"def list_tenants_for_circles(args = {}) \n get(\"/tenants.json/circles\", args)\nend",
"def index\n @lobbies = Lobby.all\n\n respond_with @lobbies, {:except => [:id, :user_id]}\n end",
"def index\n # Block execution if there is no current user\n if(current_user.blank?)\n return render json:{\n errors: \"true\",\n message: \"User not connected\"\n }, status: 401\n end\n\n user = User.find(current_user.id)\n logement = Logement.find_by(id:params[:logement_id])\n bain_demi = BainDemi.find_by(logement_id: params[:logement_id])\n bain_entier = BainEntier.find_by(logement_id: params[:logement_id])\n cuisine = Cuisine.find_by(logement_id: params[:logement_id])\n kit= Kitchenette.find_by(logement_id: params[:logement_id])\n\n \n render json:{\n bain_demi:bain_demi, bain_entier:bain_entier, cuisine:cuisine, kit:kit\n }\n end",
"def show\n @lent = Lent.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lent }\n end\n end",
"def index\n if params[:title]\n @boats = Boat.where title: params[:title]\n else\n if params[:open_seats]\n @boats = Boat.where open_seats: params[:open_seats]\n else\n @boats = Boat.all\n end\n end\n render json: @boats\n end",
"def index\n\t\tboats = Boat.all\n \trender json: boats, status: 200\n\tend",
"def client_choose(offset = 10, limit = 20)\n response = Net::HTTP.get(\n URI(\"https://pokeapi.co/api/v2/pokemon/?offset=#{offset}&limit=#{limit}\")\n )\n \n JSON.parse(response)\nend",
"def show\n render \"api/v1/bounties/show\"\n end",
"def bills(options = {})\n get('/bills', options)\n end",
"def index\n\t\t@leads = Lead.all\n\t\t\n\t\t\n\n\t\tlogger.info params[:status]\n\t\trespond_to do |format|\n\t\t format.html # index.html.erb\n\t\t format.json { render json: @leads }\n\t\tend\n\tend",
"def show\n @lobby = Lobby.find_by_id_str(params[:id])\n\n respond_with @lobby, {:except => [:id, :user_id]}\n end",
"def show\n @bottling = Bottling.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @bottling }\n end\n end",
"def show\n @Love = Love.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @Love }\n end\n end",
"def index \n local = params[:local]\n \n if (local.to_s.empty?)\n render json: 'Not found', status: 404 \n else\n params = {:query => local, :access_key => \"f613d33c4f74fc5b648685dc3428d345\"}\n conn = Faraday.get(\"http://api.weatherstack.com/current\", params) do |req|\n req.headers['Content-Type'] = 'application/json'\n end\n render json: conn.body \n end\n end",
"def index\n # only list current user's hangouts\n @hangouts = current_user.hangouts.order(\"start_date_time DESC\").page(params[:page]).per(10)\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @hangouts }\n end\n end",
"def meals\n get(\"/user/#{@user_id}/meals.json\")\n end",
"def index\n get('')\n end",
"def show\n @supplies_loan = SuppliesLoan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @supplies_loan }\n end\n end",
"def allergies\n raise UserNotAuthenticated unless access_token\n\n get('records/allergies')\n end",
"def index\n response = HTTParty.get('http://okta-api:8080/pets/v1/cats', {headers: {\"X-Token\"=> session[:oktastate][:credentials][:token]}})\n if response.code == 200\n @cats = JSON.parse(response.body)\n else\n @cats = []\n end\n end",
"def index\n @recent = Highfive.recent.approved\n @leaders = User.leaders\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @highfives }\n end\n end",
"def show\n @pinglun = Pinglun.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @pinglun }\n end\n end",
"def index\n if @item\n @inter_library_loans = @item.inter_library_loans.page(params[:page])\n else\n @inter_library_loans = InterLibraryLoan.page(params[:page])\n end\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @inter_library_loans }\n format.rss { render layout: false }\n format.atom\n end\n end",
"def show\n @player_loan = PlayerLoan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player_loan }\n end\n end",
"def index\n @pledges = Pledge.where('user_id = ?', current_user.id)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pledges }\n end\n end",
"def index\n @bounties = Bounty.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @bounties }\n end\n end",
"def show\n @law = Law.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @law }\n end\n end",
"def index\n slogans = Slogan.order('id ASC');\n render json: {\n status: 'Success',\n message: 'Loaded slogans',\n data: slogans,\n code: 200,\n }\n end",
"def show\n #@users = User.search(params[:search]).order(sort_column + \" \" + sort_direction).paginate(:per_page => 5, :page => params[:page]) \n #added for .js otherwise json and html were anyway supported\n #http://davidsulc.com/blog/2011/04/10/implementing-a-public-api-in-rails-3/\n @lovedone = Lovedone.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n #prevented by forgery protection\n format.js { render :json => @lovedone, :callback => params[:callback] }\n format.json { render :json => @lovedone }\n format.xml { render :xml => @lovedone }\n end\n \n end",
"def show\n #@users = User.search(params[:search]).order(sort_column + \" \" + sort_direction).paginate(:per_page => 5, :page => params[:page]) \n #added for .js otherwise json and html were anyway supported\n #http://davidsulc.com/blog/2011/04/10/implementing-a-public-api-in-rails-3/\n @lovedone = Lovedone.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n #prevented by forgery protection\n format.js { render :json => @lovedone, :callback => params[:callback] }\n format.json { render :json => @lovedone }\n format.xml { render :xml => @lovedone }\n end\n \n end",
"def show\n @breadcrumb = 'read'\n @bank = Bank.find(params[:id])\n @bank_offices = @bank.bank_offices.order(\"code\")\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @bank }\n end\n end",
"def api\n url = \"https://wagon-dictionary.herokuapp.com/#{@answer}\"\n response = URI.open(url).read\n json = JSON.parse(response)\n return json['found']\n end",
"def index\n @sayings = Saying.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @sayings }\n end\n end",
"def show\n @bruger = Bruger.find_by_id(current_user.id)\n @onske = Onske.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @onske }\n end\n end",
"def index\n bookings = Booking.all\n\n if bookings\n render json: { status: 'SUCCESS', message: 'Successfuly got all bookings', data: bookings }, status: :ok\n else\n render json: { status: 'ERROR', message: 'Something went wrong' }, status: :unprocessable_entity\n end\n end",
"def hearings(options = {})\n get('/hearings', options)\n end",
"def index\n @alleys = Alley.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @alleys }\n end\n end",
"def index\n @biddings = Bidding.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @biddings }\n end\n end",
"def index\n \tif params[:for_timeline]\n\t\t\t@bills = Bill.where(:initiator_id.in => params[:politicians]).where(:complete =>true).limit(10)\n\t\telse\n\t \t@bills = Bill.all.limit(10)\n \tend\n\n respond_to do |format|\n format.json { render json: @bills.to_json(:include => {:initiator => {:only =>[:name]}}) }\n end\n\n end",
"def index\n url = \"https://data.cityofchicago.org/resource/x2n5-8w5q.json\"\n options = { :body => {:status => text}, :basic_auth => @auth }\n @response = HTTParty.get(url, options)\n\n @crime = Hash.new\n\n #@crime['block'] = @response[0]['block']\n @crime = @response\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @gittos }\n end\n end",
"def index\n @admin_loans = Loan.pending\n end",
"def index\n bookings = Room.all\n\n if bookings\n render json: { status: 'SUCCESS', message: 'Successfuly got all rooms', data: bookings }, status: :ok\n else\n render json: { status: 'ERROR', message: 'Something went wrong' }, status: :unprocessable_entity\n end\n end",
"def index\n @loans = if @customer\n @customer.loans\n elsif params[:q].present?\n Loan.search(params[:q])\n else\n Loan.all\n end\n @loans = @loans.includes(:customer).references(:customer).page params[:page]\n end",
"def current\n batles = BatlePool.instance.all\n render json: batles,\n except: :location_id,\n include: [:heroes, :threat],\n status: :ok\n end",
"def index\n @lents = if params[:all]\n #Lent.order(\"updated_at DESC\")\n Lent.order(\"lent_on DESC\")\n else\n Lent.where(:condition => Lent::Lent).order(:car_id)\n end\n @today = Date.today\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @lents }\n end\n end",
"def index\n @honey_badgers = HoneyBadger.all\n respond_to do |format|\n format.html\n format.json { render json: @honey_badgers }\n end\n end",
"def index\n @bills = @dwelling.bills\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @bills }\n end\n end",
"def index\n @loan = Loan.all\n end",
"def index\n @leads = Lead.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @leads }\n end\n end",
"def show\n @litra = Litra.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @litra }\n end\n end",
"def show\n @lore = Lore.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lore }\n end\n end",
"def index\n @balloons = Balloon.order('created_at DESC');\n render json: {status: 'SUCCESS', message:'Loaded balloons', data:@balloons},status: :ok\n end",
"def librarian_view\n @response, @document = search_service.fetch(params[:id])\n respond_to do |format|\n format.html { render layout: false }\n format.json\n end\n end",
"def index\n\tadd_breadcrumb \"Listado de librerias\", :librerias_index_path\n @librerias = Libreria.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @librerias }\n end\n end",
"def index\n @gets = Get.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @gets }\n end\n end",
"def index\n @reward_and_levels = RewardAndLevel.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @reward_and_levels }\n end\n end",
"def list_tenants_for_circle(args = {}) \n get(\"/tenantcircles.json/tenants\", args)\nend",
"def show\n @inter_library_loan = InterLibraryLoan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @inter_library_loan }\n end\n end",
"def index\n @bills = Bill.all_cached\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @bills }\n end\n end",
"def show\n @lbc = Lbc.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lbc }\n end\n end",
"def index\n\n @bans = @cloud.bans.where(\n params.select { |k,v| [:offender_id,:enforcer_id].include?(k.to_sym) }\n ).order_by(due: :desc)\n\n render status: 200\n end",
"def show\n @lodge = Lodge.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lodge }\n end\n end",
"def index\n render json: Lobby.all.as_json( only: [:id, :name] )\n end",
"def lws_api_get(path)\n # See also catalog_controller for use of ENV['LWS_...']\n url ||= ENV['LWS_API_URL']\n url ||= \"#{ENV['LWS_CORE_URL']}/api\" if ENV['LWS_CORE_URL']\n \n # http://localhost:8888/api/collections\n resp = Net::HTTP.get_response(URI.parse(\"#{url || 'http://127.0.0.1:8888/api'}#{path}\"))\n result = JSON.parse(resp.body)\n end",
"def show\n @lbd = Lbd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lbd }\n end\n end",
"def index\n @listings = Listing.by_user(current_user).all\n\n render json: @listings\n end",
"def show\n @loan = Loan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @loan }\n end\n end",
"def GET; end",
"def show\n @kennel_litter = KennelLitter.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @kennel_litter }\n end\n end",
"def index\n @rents = Rent.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @rents }\n end\n end",
"def get(path, query={})\n request_json :get, path, query\n end",
"def info\n get '/'\n end",
"def index\n @users = User.where(:alive => true).order(\"nick ASC\")\n @headline = t(:all_users)\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @users }\n end\n end",
"def index\n head 404\n # @api_v1_followers = Api::V1::Follower.all\n\n # render json: @api_v1_followers\n end",
"def index\n if params[:user_id]\n @rents = find_user.rents\n render json: @rents\n elsif params[:book_id]\n @rents = find_book.rents\n render json: @rents\n else\n @rents = Rent.all\n render json: @rents\n end\n end",
"def show\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @reward_and_level }\n end\n end",
"def http( *args )\n p http_get( *args )\n end",
"def index\n @blasts = Blast.accessible_by(current_ability)\n \n if params[:filter] && !params[:filter].blank?\n @blasts = Blast.where(\"title LIKE ?\", \"%#{params[:filter]}%\")\n end\n \n if params[:status] && !params[:status].blank?\n @blasts = Blast.where(:status => params[:status])\n end\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @blasts.to_json(:include => [:output, :owner, :entry])}\n end\n end",
"def index \n fans = Fan.all \n render json: fans \n end",
"def index\n weathers = Weather.all\n render json: weathers, status: 200\n end",
"def returns\n @book.returns(@user)\n return render json: { object: 'Loan'}, status: :ok\n rescue Exceptions::InvalidLoan\n render json: { object: 'Loan'}, status: :not_found\n rescue Exceptions::LowAccountBalance\n render json: { object: 'User'}, status: :internal_server_error # Inconsistence found, missing measures, shouldn't happen\n rescue => exception\n Rails.logger.debug exception\n return render json: { object: 'Loan'}, status: :internal_server_error # Missing checks...\n end",
"def show\n @litter = Litter.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @litter }\n end\n end",
"def new\n @loan = Loan.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @loan }\n end\n end"
] |
[
"0.6826537",
"0.6537598",
"0.64159024",
"0.6415585",
"0.6327823",
"0.62531495",
"0.6161418",
"0.6144067",
"0.6075828",
"0.60086364",
"0.59481794",
"0.5947637",
"0.593769",
"0.58940655",
"0.5810782",
"0.58028126",
"0.579234",
"0.5788496",
"0.5757764",
"0.5750815",
"0.5743334",
"0.5739043",
"0.5735662",
"0.571129",
"0.56980115",
"0.5684735",
"0.5668641",
"0.56620276",
"0.56507313",
"0.5646416",
"0.56456035",
"0.56438696",
"0.5641443",
"0.5637661",
"0.56373674",
"0.5636698",
"0.5627599",
"0.56189436",
"0.56152743",
"0.559678",
"0.5596635",
"0.5595393",
"0.5586387",
"0.5578058",
"0.5563637",
"0.5563637",
"0.555561",
"0.5555276",
"0.55499625",
"0.55466026",
"0.55348974",
"0.55296856",
"0.5528905",
"0.5528023",
"0.551441",
"0.55129975",
"0.55126584",
"0.5512423",
"0.5501189",
"0.5499936",
"0.5495607",
"0.5495551",
"0.549533",
"0.5491706",
"0.5489054",
"0.54848343",
"0.5484346",
"0.5480616",
"0.54804385",
"0.5471775",
"0.54699224",
"0.5468728",
"0.5466547",
"0.54660815",
"0.5461979",
"0.5454293",
"0.5453923",
"0.54535633",
"0.54506177",
"0.54478234",
"0.5445743",
"0.54416144",
"0.54389143",
"0.5438781",
"0.54371065",
"0.5434985",
"0.5433976",
"0.5432655",
"0.5429669",
"0.5429655",
"0.54295135",
"0.5429389",
"0.54271597",
"0.54170495",
"0.54169613",
"0.54166776",
"0.5413781",
"0.54110813",
"0.5407912"
] |
0.60713345
|
10
|
GET /loans/1 or /loans/1.json
|
def show
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def specific\n @state = State.find(params[:id])\n @loans = @state.loans.where(:purpose_id == params[:purpose_id])\n render json: { state: @state, loans: @loans }\n end",
"def show\n @loan = Loan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @loan }\n end\n end",
"def index_loans_for_bundle\n @bundles = Bundle.find(params[:id])\n\n respond_to do |format|\n format.html { render 'loans/index'}\n format.xml { render :xml => @bundles }\n end\n end",
"def loans\n url = \"#{LOANS_PATH}/pre-approved\"\n data = perform_get(url)\n data || {}\n end",
"def index\n @loans = Loan.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @loans }\n end\n end",
"def index\n render json: Loan.all\n end",
"def client_choose(offset = 10, limit = 20)\n response = Net::HTTP.get(\n URI(\"https://pokeapi.co/api/v2/pokemon/?offset=#{offset}&limit=#{limit}\")\n )\n \n JSON.parse(response)\nend",
"def index\n @losts = Lost.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @losts }\n end\n end",
"def index\n @money = Money.all\n require 'net/http'\n require 'json'\n @url = 'https://api.coinmarketcap.com/v1/ticker/'\n @uri = URI(@url)\n @response = Net::HTTP.get(@uri)\n @lookup_money = JSON.parse(@response)\n end",
"def index\n @lophs = Loph.all\n respond_to do |format|\n format.html\n format.json { render json: @lophs}\n end\n end",
"def index\n @loans = Loan.all\n end",
"def index\n @loans = Loan.all\n end",
"def index\n @loans = @tool.loans.all\n end",
"def show\n @lobby = Lobby.find_by_id_str(params[:id])\n\n respond_with @lobby, {:except => [:id, :user_id]}\n end",
"def show\n @lent = Lent.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lent }\n end\n end",
"def index\n @litters = Litter.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @litters }\n end\n end",
"def show\n @pinglun = Pinglun.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @pinglun }\n end\n end",
"def show\n @litra = Litra.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @litra }\n end\n end",
"def show\n @litter = Litter.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @litter }\n end\n end",
"def current\n batles = BatlePool.instance.all\n render json: batles,\n except: :location_id,\n include: [:heroes, :threat],\n status: :ok\n end",
"def show\n @bottling = Bottling.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @bottling }\n end\n end",
"def show\n render \"api/v1/bounties/show\"\n end",
"def show\n @inter_library_loan = InterLibraryLoan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @inter_library_loan }\n end\n end",
"def show\n @player_loan = PlayerLoan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @player_loan }\n end\n end",
"def index\n @laws = Law.sorted\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @laws }\n end\n end",
"def show\n @supplies_loan = SuppliesLoan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @supplies_loan }\n end\n end",
"def index\n @current_user = User.find(session[:user_id])\n \n @loans = Loan.all\n end",
"def show\n @Love = Love.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @Love }\n end\n end",
"def set_loan\n @loan = Loan.where(id: params[:id]).first\n render json: 'not_found', status: :not_found if (@loan.nil?)\n end",
"def show\n @lbc = Lbc.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lbc }\n end\n end",
"def show\n @kennel_litter = KennelLitter.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @kennel_litter }\n end\n end",
"def show\n @lore = Lore.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lore }\n end\n end",
"def list_tenants_for_circles(args = {}) \n get(\"/tenants.json/circles\", args)\nend",
"def show\n @law = Law.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @law }\n end\n end",
"def show\n @lodge = Lodge.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lodge }\n end\n end",
"def show\n @borrower = Borrower.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @borrower }\n end\n end",
"def index\n @lobbies = Lobby.all\n\n respond_with @lobbies, {:except => [:id, :user_id]}\n end",
"def index\n @laws = Law.ordered_roots\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @laws }\n end\n end",
"def show\n @lector = Lector.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lector }\n end\n end",
"def index\n url = \"https://data.cityofchicago.org/resource/x2n5-8w5q.json\"\n options = { :body => {:status => text}, :basic_auth => @auth }\n @response = HTTParty.get(url, options)\n\n @crime = Hash.new\n\n #@crime['block'] = @response[0]['block']\n @crime = @response\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @gittos }\n end\n end",
"def new\n @loan = Loan.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @loan }\n end\n end",
"def show\n @lbd = Lbd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lbd }\n end\n end",
"def show\n @loan = Loan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @loan }\n end\n end",
"def show\n @basin = Basin.find(params[:id])\n\n @client = YahooWeather::Client.new \n @response = @client.fetch_by_location('Massingir, Gaza, Mz','c')\n @reponse2 = @client.fetch_by_location('Louis Trichardt, Limpopo, South Africa','c')\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @basin }\n\n end\n end",
"def show\n @baton = Baton.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @baton }\n end\n end",
"def index\n @loves = Love.all\n render json: @loves\n end",
"def show\n @breadcrumb = 'read'\n @bank = Bank.find(params[:id])\n @bank_offices = @bank.bank_offices.order(\"code\")\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @bank }\n end\n end",
"def show\n @bruger = Bruger.find_by_id(current_user.id)\n @onske = Onske.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @onske }\n end\n end",
"def show\n @lbdd = Lbdd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lbdd }\n end\n end",
"def show\n @lbdd = Lbdd.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lbdd }\n end\n end",
"def show\n @roof = Roof.find(params[:roof_id])\n @status = @roof.statuses.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @status }\n end\n end",
"def show\n @webling = Webling.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @webling }\n end\n end",
"def index\n if @item\n @inter_library_loans = @item.inter_library_loans.page(params[:page])\n else\n @inter_library_loans = InterLibraryLoan.page(params[:page])\n end\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @inter_library_loans }\n format.rss { render layout: false }\n format.atom\n end\n end",
"def meals\n get(\"/user/#{@user_id}/meals.json\")\n end",
"def show\n @lid = Lid.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lid }\n end\n end",
"def show\n @witch = Witch.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @witch }\n end\n end",
"def show\n @potluck = Potluck.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @potluck }\n end\n end",
"def show\n @leito = Leito.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @leito }\n end\n end",
"def show\n @lei = Lei.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lei }\n end\n end",
"def show\n @release_loan = ReleaseLoan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @release_loan }\n end\n end",
"def index\n # Block execution if there is no current user\n if(current_user.blank?)\n return render json:{\n errors: \"true\",\n message: \"User not connected\"\n }, status: 401\n end\n\n user = User.find(current_user.id)\n logement = Logement.find_by(id:params[:logement_id])\n bain_demi = BainDemi.find_by(logement_id: params[:logement_id])\n bain_entier = BainEntier.find_by(logement_id: params[:logement_id])\n cuisine = Cuisine.find_by(logement_id: params[:logement_id])\n kit= Kitchenette.find_by(logement_id: params[:logement_id])\n\n \n render json:{\n bain_demi:bain_demi, bain_entier:bain_entier, cuisine:cuisine, kit:kit\n }\n end",
"def bills(options = {})\n get('/bills', options)\n end",
"def show\n @bet = Bet.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @bet }\n end\n end",
"def index\n slogans = Slogan.order('id ASC');\n render json: {\n status: 'Success',\n message: 'Loaded slogans',\n data: slogans,\n code: 200,\n }\n end",
"def http_get_early(request, response)\n params = request.query_parameters\n return http_get(request, response) if params['sabreAction'] == 'info'\n end",
"def show\n @livestock = Livestock.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @livestock }\n end\n end",
"def index\n\t\tboats = Boat.all\n \trender json: boats, status: 200\n\tend",
"def show\n @nyan = Nyan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @nyan }\n end\n end",
"def show\n @love = Love.find(params[:id])\n render json: @love\n end",
"def get(path, query={})\n request_json :get, path, query\n end",
"def index\n @loan = Loan.all\n end",
"def lws_api_get(path)\n # See also catalog_controller for use of ENV['LWS_...']\n url ||= ENV['LWS_API_URL']\n url ||= \"#{ENV['LWS_CORE_URL']}/api\" if ENV['LWS_CORE_URL']\n \n # http://localhost:8888/api/collections\n resp = Net::HTTP.get_response(URI.parse(\"#{url || 'http://127.0.0.1:8888/api'}#{path}\"))\n result = JSON.parse(resp.body)\n end",
"def show\n @lieu = Lieu.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @lieu }\n end\n end",
"def show\n @supplies_providers_loan = SuppliesProvidersLoan.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @supplies_providers_loan }\n end\n end",
"def list\n get('/')\n end",
"def index\n \tif params[:for_timeline]\n\t\t\t@bills = Bill.where(:initiator_id.in => params[:politicians]).where(:complete =>true).limit(10)\n\t\telse\n\t \t@bills = Bill.all.limit(10)\n \tend\n\n respond_to do |format|\n format.json { render json: @bills.to_json(:include => {:initiator => {:only =>[:name]}}) }\n end\n\n end",
"def librarian_view\n @response, @document = search_service.fetch(params[:id])\n respond_to do |format|\n format.html { render layout: false }\n format.json\n end\n end",
"def show\n @mood = Mood.find(params[:id])\n respond_to do |format|\n format.any { render :json => @mood }\n end\n end",
"def index\n @bounties = Bounty.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @bounties }\n end\n end",
"def index\n @loadbalancers = getmydata(\"Loadbalancer\")\n pagination\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @loadbalancers }\n end\n end",
"def show\n @lot = Lot.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @lot }\n end\n end",
"def show\n @user_livestock = UserLivestock.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @user_livestock }\n end\n end",
"def show\n render json: @league, status: :ok\n end",
"def index\n @recent = Highfive.recent.approved\n @leaders = User.leaders\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @highfives }\n end\n end",
"def show\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @reward_and_level }\n end\n end",
"def show\n @lending = Lending.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @lending }\n end\n end",
"def index\n get('')\n end",
"def index\n @bills = @dwelling.bills\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @bills }\n end\n end",
"def show\n\tadd_breadcrumb \"Datos de la librería\", :librerias_path\n @libreria = Libreria.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @libreria }\n end\n end",
"def index\n\t\t@leads = Lead.all\n\t\t\n\t\t\n\n\t\tlogger.info params[:status]\n\t\trespond_to do |format|\n\t\t format.html # index.html.erb\n\t\t format.json { render json: @leads }\n\t\tend\n\tend",
"def index \n local = params[:local]\n \n if (local.to_s.empty?)\n render json: 'Not found', status: 404 \n else\n params = {:query => local, :access_key => \"f613d33c4f74fc5b648685dc3428d345\"}\n conn = Faraday.get(\"http://api.weatherstack.com/current\", params) do |req|\n req.headers['Content-Type'] = 'application/json'\n end\n render json: conn.body \n end\n end",
"def show\n @bottle = Bottle.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @bottle }\n \tformat.json { render :json => @bottle }\n\t\tend\n end",
"def index\n response = HTTParty.get('http://okta-api:8080/pets/v1/cats', {headers: {\"X-Token\"=> session[:oktastate][:credentials][:token]}})\n if response.code == 200\n @cats = JSON.parse(response.body)\n else\n @cats = []\n end\n end",
"def index\n if params[:title]\n @boats = Boat.where title: params[:title]\n else\n if params[:open_seats]\n @boats = Boat.where open_seats: params[:open_seats]\n else\n @boats = Boat.all\n end\n end\n render json: @boats\n end",
"def show\n @leader = Leader.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @leader }\n end\n end",
"def show\n #@users = User.search(params[:search]).order(sort_column + \" \" + sort_direction).paginate(:per_page => 5, :page => params[:page]) \n #added for .js otherwise json and html were anyway supported\n #http://davidsulc.com/blog/2011/04/10/implementing-a-public-api-in-rails-3/\n @lovedone = Lovedone.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n #prevented by forgery protection\n format.js { render :json => @lovedone, :callback => params[:callback] }\n format.json { render :json => @lovedone }\n format.xml { render :xml => @lovedone }\n end\n \n end",
"def show\n #@users = User.search(params[:search]).order(sort_column + \" \" + sort_direction).paginate(:per_page => 5, :page => params[:page]) \n #added for .js otherwise json and html were anyway supported\n #http://davidsulc.com/blog/2011/04/10/implementing-a-public-api-in-rails-3/\n @lovedone = Lovedone.find(params[:id])\n respond_to do |format|\n format.html # show.html.erb\n #prevented by forgery protection\n format.js { render :json => @lovedone, :callback => params[:callback] }\n format.json { render :json => @lovedone }\n format.xml { render :xml => @lovedone }\n end\n \n end",
"def show\n @saying = Saying.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @saying }\n end\n end",
"def index\n @requests = Request.where(status: -1)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @requests }\n end\n end",
"def index\n @lents = if params[:all]\n #Lent.order(\"updated_at DESC\")\n Lent.order(\"lent_on DESC\")\n else\n Lent.where(:condition => Lent::Lent).order(:car_id)\n end\n @today = Date.today\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @lents }\n end\n end",
"def show\n @boat = Boat.find(params[:id])\n\n render json: @boat\n end"
] |
[
"0.6543157",
"0.6495447",
"0.6494963",
"0.6491412",
"0.6355428",
"0.6291733",
"0.61194766",
"0.6079159",
"0.6042374",
"0.6035625",
"0.6019342",
"0.6019342",
"0.59851944",
"0.59557253",
"0.5955025",
"0.5908463",
"0.5897701",
"0.58903205",
"0.5868023",
"0.5864134",
"0.5817883",
"0.5816347",
"0.5815867",
"0.580116",
"0.57990694",
"0.5797052",
"0.5793972",
"0.5792784",
"0.5773295",
"0.57664245",
"0.5725542",
"0.5701689",
"0.5666594",
"0.56628156",
"0.56541574",
"0.5653778",
"0.5650333",
"0.564821",
"0.5646151",
"0.5644114",
"0.5642661",
"0.5638402",
"0.5637086",
"0.5632429",
"0.56258607",
"0.56016797",
"0.56005716",
"0.5598675",
"0.5582623",
"0.5582623",
"0.5579119",
"0.5578512",
"0.5577499",
"0.55755997",
"0.5573643",
"0.5572912",
"0.5572107",
"0.5561592",
"0.5559039",
"0.5544994",
"0.553884",
"0.55264646",
"0.5520739",
"0.5518551",
"0.55099595",
"0.55016667",
"0.54946345",
"0.54905945",
"0.54821646",
"0.5480961",
"0.5478666",
"0.5475441",
"0.5472675",
"0.5470687",
"0.54659086",
"0.5465297",
"0.546219",
"0.5454421",
"0.5446435",
"0.54438686",
"0.54416007",
"0.543405",
"0.54326195",
"0.54322624",
"0.54293936",
"0.5429254",
"0.54267144",
"0.54262775",
"0.542515",
"0.5424872",
"0.5424797",
"0.5424521",
"0.5423175",
"0.5422953",
"0.5420047",
"0.5416794",
"0.5416794",
"0.54130983",
"0.541277",
"0.541252",
"0.54125077"
] |
0.0
|
-1
|
POST /loans or /loans.json
|
def create
@loan = Loan.new(loan_params.merge(user: current_user))
respond_to do |format|
if @loan.save
format.html { redirect_to books_path, notice: "Book added to your library" }
else
format.html { render :new, status: :unprocessable_entity }
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create\n logger.debug \"!! create\"\n loan_params\n @loan = Loan.new(loan_params)\n # logger.debug loan_params\n\n respond_to do |format|\n if @loan.save\n format.html { redirect_to @loan, notice: 'Loan was successfully created.' }\n format.json { render action: 'show', status: :created, location: @loan }\n else\n format.html { render action: 'new' }\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def loans\n url = \"#{LOANS_PATH}/pre-approved\"\n data = perform_get(url)\n data || {}\n end",
"def new\n @loan = Loan.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @loan }\n end\n end",
"def moip_post\n @nasp_rail = NaspRail.new(params[:nasp_rail])\n\n format.html { redirect_to @nasp_rail, :notice => 'Nova entrada criada com sucesso.' }\n format.json { render :json => @nasp_rail, :status => :created, :location => @nasp_rail }\n end",
"def create\n @home_loan = HomeLoan.new(data: params[:home_loan])\n\n respond_to do |format|\n if @home_loan.save\n format.html { redirect_to @home_loan, notice: 'Home loan was successfully created.' }\n format.json { render :show, status: :created, location: @home_loan }\n else\n format.html { render :new }\n format.json { render json: @home_loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @loan = Loan.new(params[:loan])\n\n respond_to do |format|\n if @loan.save\n flash[:notice] = 'Loan was successfully created.'\n format.html { redirect_to(@loan) }\n format.xml { render :xml => @loan, :status => :created, :location => @loan }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @loan.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def createLoanRequest\n puts 'GOT REQUEST'\n puts params.inspect\n\n # Persist to the database for some reason\n req = LoanRequest.new\n req.ssn = params[:ssn]\n req.creditScore = params[:creditScore]\n req.loanAmount = params[:loanAmount]\n req.loanDuration = params[:loanDuration]\n req.save\n\n reply_to = request.headers['HTTP_REPLY_TO']\n\n #TODO: Get a job in a bank and find out how this are calculated\n randomInterestRate = randomInterest(1, 5).round(2)\n\n result = {\n interestRate: randomInterestRate,\n ssn: req.ssn\n }\n\n conn = Bunny.new\n conn.start\n ch = conn.create_channel\n q = ch.queue(reply_to)\n\n ch.default_exchange.publish(result.to_json, routing_key: q.name)\n\n render :json => result.to_json\n end",
"def create\n @bottling = Bottling.new(params[:bottling])\n\n respond_to do |format|\n if @bottling.save\n format.html { redirect_to @bottling, notice: 'bottling was successfully created.' }\n format.json { render json: @bottling, status: :created, location: @bottling }\n else\n format.html { render action: \"new\" }\n format.json { render json: @bottling.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @lading = Lading.new(lading_params)\n\n respond_to do |format|\n if @lading.save\n format.html { redirect_to @lading, notice: 'Lading was successfully created.' }\n format.json { render :show, status: :created, location: @lading }\n else\n format.html { render :new }\n format.json { render json: @lading.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_loan\n book = Book.find(params[:book_id])\n book_loan = Log.create!(user: current_user, book: book, classification: Log.classifications[:book_loan],\n date: DateTime.now, due_date: 3.weeks.from_now)\n render json: book_loan, book_loan: true, status: :created\n end",
"def POST; end",
"def create\n @loan = Loan.new(loan_params)\n\n respond_to do |format|\n if @loan.save\n @item = @loan.item\n format.html { redirect_to @item, notice: I18n.t('views.loan.created') }\n format.json { render :show, status: :created, location: @loan }\n else\n format.html { render :new }\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @loan = Loan.new(loan_params)\n @book = Book.find_by( params[:book_id] )\n\n respond_to do |format|\n if @loan.save\n format.html { redirect_to @loan, notice: 'Book successfully borrowed' }\n format.json { render :show, status: :created, location: @loan }\n else\n format.html { redirect_to books_path, alert: 'Book not available' }\n end\n end\n end",
"def create\n @loanable = current_user.loanables.new(loanable_params)\n\n respond_to do |format|\n if @loanable.save\n format.html { redirect_to users_loanable_path(@loanable), notice: 'Loanable was successfully created.' }\n format.json { render :show, status: :created, location: @loanable }\n else\n format.html { render :new }\n format.json { render json: @loanable.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @loan = Loan.new(loan_params)\n respond_to do |format|\n if @loan.save\n Reservation.check_and_delete_reservation(@loan.user_id, @loan.book_id)\n if !params[:loan][:prev_loan_id].blank?\n prev_loan_id = params[:loan][:prev_loan_id]\n Loan.return_book(Loan.get_loan_by_id(prev_loan_id))\n end\n format.html { redirect_to loans_user_all_path(:id => @loan.user_id), notice: 'Výpůjčka byla úspěšně uložena do databáze.' }\n format.json { render :show, status: :created, location: @loan }\n else\n flash.now[:error] = @loan.errors.full_messages\n @users = User.all.order(:surname)\n @book_id = @loan.book_id\n @book = Book.search_by_czu_number(@book_id)\n @loan_length = Setting.get_loan_time\n @all_reservations = Reservation.get_all_book_reservations(@book_id).order(\"created_at ASC\")\n @reservation_count = @all_reservations.count\n format.html { render :new, error: 'Výpůjčka nebyla uložena do databáze.'}\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(data = {})\n call data, method: :post\n end",
"def create\n @loan = Loan.new loan_params\n\n if @loan.save\n redirect_to @loan\n else\n render 'new'\n end\n end",
"def create\n @lomein = Lomein.new(lomein_params)\n\n respond_to do |format|\n if @lomein.save\n format.html { redirect_to @lomein, notice: 'Lomein was successfully created.' }\n format.json { render :show, status: :created, location: @lomein }\n else\n format.html { render :new }\n format.json { render json: @lomein.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @loja = Loja.new(params[:loja])\n\n respond_to do |format|\n if @loja.save\n format.html { redirect_to @loja, notice: 'Loja criada com sucesso' }\n format.json { render json: @loja, status: :created, location: @loja }\n else\n format.html { render action: \"new\" }\n format.json { render json: @loja.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @banned = Banned.new(banned_params)\n\n respond_to do |format|\n if @banned.save\n format.html { redirect_to @banned, notice: 'Banned was successfully created.' }\n format.json { render :show, status: :created, location: @banned }\n else\n format.html { render :new }\n format.json { render json: @banned.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @logloan = Logloan.new(logloan_params)\n\n respond_to do |format|\n if @logloan.save\n format.html { redirect_to @logloan, notice: 'Logloan was successfully created.' }\n format.json { render :show, status: :created, location: @logloan }\n else\n format.html { render :new }\n format.json { render json: @logloan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(request)\n # sure thing!\n json_response(200, { message: \"This dummy POST endpoint didn't do anything.\" })\n end",
"def create\n @player_loan = PlayerLoan.new(params[:player_loan])\n\n respond_to do |format|\n if @player_loan.save\n format.html { redirect_to @player_loan, notice: 'Player loan was successfully created.' }\n format.json { render json: @player_loan, status: :created, location: @player_loan }\n else\n format.html { render action: \"new\" }\n format.json { render json: @player_loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(*args)\n request :post, *args\n end",
"def post(*args)\n request(:post, *args)\n end",
"def set_loan\n @loan = Loan.where(id: params[:id]).first\n render json: 'not_found', status: :not_found if (@loan.nil?)\n end",
"def new\n @pinglun = Pinglun.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @pinglun }\n end\n end",
"def specific\n @state = State.find(params[:id])\n @loans = @state.loans.where(:purpose_id == params[:purpose_id])\n render json: { state: @state, loans: @loans }\n end",
"def create\n @lodging = Lodging.new(lodging_params)\n\n respond_to do |format|\n if @lodging.save\n format.html { redirect_to @lodging, notice: 'Lodging was successfully created.' }\n format.json { render :show, status: :created, location: @lodging }\n else\n format.html { render :new }\n format.json { render json: @lodging.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @loan = Loan.new(loan_params)\n\n respond_to do |format|\n if @loan.save\n set_cookie\n format.html { redirect_to \"/loans/#{@loan.id}/step2\", notice: 'Loan was successfully submitted.' }\n format.json { render :show, status: :created, location: @loan }\n else\n format.html { render :new }\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @loan_type = LoanType.new(loan_type_params)\n\n respond_to do |format|\n if @loan_type.save\n format.html { redirect_to @loan_type, notice: 'Loan type was successfully created.' }\n format.json { render :show, status: :created, location: @loan_type }\n else\n format.html { render :new }\n format.json { render json: @loan_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def data_to_api(snack_name, snack_location, snack_optional)\n RestClient.post ENV['NERDERY_API'], { name: snack_name,\n location: snack_location,\n optional: snack_optional\n }.to_json, content_type: :json\n end",
"def create\n @loan_log = LoanLog.new(loan_log_params)\n\n respond_to do |format|\n if @loan_log.save\n format.html { redirect_to @loan_log, notice: 'Loan log was successfully created.' }\n format.json { render :show, status: :created, location: @loan_log }\n else\n format.html { render :new }\n format.json { render json: @loan_log.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @release_loan = ReleaseLoan.new(params[:release_loan])\n\n respond_to do |format|\n if @release_loan.save\n format.html { redirect_to @release_loan, notice: 'Release loan was successfully created.' }\n format.json { render json: @release_loan, status: :created, location: @release_loan }\n else\n format.html { render action: \"new\" }\n format.json { render json: @release_loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bottling = Bottling.new(bottling_params)\n\n respond_to do |format|\n if @bottling.save\n format.html { redirect_to [:admin, @bottling], notice: 'Bottling was successfully created.' }\n format.json { render :show, status: :created, location: @bottling }\n else\n format.html { render :new }\n format.json { render json: @bottling.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @loan = @tool.loans.new(create_loan_params)\n\n @loan.borrower_id = session[:student_id]\n @tool.update(:quantity => @tool.quantity - @loan.tool_quantity)\n @loan.accepted = false\n\n respond_to do |format|\n if @loan.save\n format.html { redirect_to home_path, notice: 'Loan was successfully created.' }\n format.json { render :show, status: :created, location: @loan }\n else\n format.html { render :new }\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @labelling = Labelling.new(params[:labelling])\n\n respond_to do |format|\n if @labelling.save\n format.html { redirect_to @labelling, notice: 'Labelling was successfully created.' }\n format.json { render json: @labelling, status: :created, location: @labelling }\n else\n format.html { render action: \"new\" }\n format.json { render json: @labelling.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @smsloan = Smsloan.new(smsloan_params)\n\n respond_to do |format|\n if @smsloan.save\n format.html { redirect_to @smsloan, notice: 'Smsloan was successfully created.' }\n format.json { render :show, status: :created, location: @smsloan }\n else\n format.html { render :new }\n format.json { render json: @smsloan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @bruger_id = current_user.id\n @bruger = Bruger.find_by_id(@bruger_id)\n @onske = Onske.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @onske }\n end\n end",
"def create_ping\n post 'ping'\n end",
"def create\n @lumberjill = Lumberjill.new(lumberjill_params)\n\n respond_to do |format|\n if @lumberjill.save\n format.html { redirect_to @lumberjill, notice: 'Lumberjill was successfully created.' }\n format.json { render :show, status: :created, location: @lumberjill }\n else\n format.html { render :new }\n format.json { render json: @lumberjill.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post operation, data={}\n body = case data\n when String\n body = data\n else\n Yajl::Encoder.encode(data)\n end\n\n request = new_request operation, body\n request.sign sts\n hydra.queue request\n hydra.run\n response = request.response\n puts response.inspect if @debug\n\n if response.code == 200\n Yajl::Parser.parse response.body\n else\n raise_error response\n end\n end",
"def create\n @loo = Loo.new(loo_params)\n\n respond_to do |format|\n if @loo.save\n format.html { redirect_to @loo, notice: 'Loo was successfully created.' }\n format.json { render :show, status: :created, location: @loo }\n else\n format.html { render :new }\n format.json { render json: @loo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @saying = Saying.new(params[:saying])\n\n respond_to do |format|\n if @saying.save\n format.html { redirect_to @saying}\n format.json { render json: @saying, status: :created, location: @saying }\n else\n format.html { render action: \"new\" }\n format.json { render json: @saying.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n owner = User.find_or_create params[:owner_id]\n name = params[:name]\n\n lobby = Lobby.create! owner: owner, name: name\n render json: lobby.as_json( only: [:id, :name] )\n end",
"def create\n @lending = Lending.new(params[:lending])\n\n respond_to do |format|\n if @lending.save\n format.html { redirect_to @lending, :notice => 'Lending was successfully created.' }\n format.json { render :json => @lending, :status => :created, :location => @lending }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @lending.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @loan = Loan.new(loan_params)\n @loan.amount = loan_params[:amount].gsub(/,/, '').to_f\n @loan.property_value = loan_params[:property_value].gsub(/,/, '').to_f\n\n if @loan.save\n # conduct first test for loan approval\n if @loan.ltv < 40\n @loan.update_attributes(:accepted => true)\n end\n redirect_to \"/loans/#{@loan.id}\"\n else\n flash[:error_hash] = @loan.errors.messages\n flash[:error] = @loan.errors.full_messages\n flash[:error_list] = @loan.errors.messages.keys\n redirect_to :back\n end\n end",
"def post_spoonacular\n # %encode ingredients to url\n encoded_ingr = URI.escape(@translated_recipe[:ingredients_list])\n # post call block :\n url = URI(\"https://spoonacular-recipe-food-nutrition-v1.p.rapidapi.com/recipes/parseIngredients?includeNutrition=true\")\n http = Net::HTTP.new(url.host, url.port)\n http.use_ssl = true\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n request = Net::HTTP::Post.new(url)\n request[\"content-type\"] = \"application/x-www-form-urlencoded\"\n request[\"x-rapidapi-key\"] = ENV[\"X_RAPIDAPI_KEY\"]\n request[\"x-rapidapi-host\"] = \"spoonacular-recipe-food-nutrition-v1.p.rapidapi.com\"\n # body of the call with ingredients and servings\n request.body = \"ingredientList=#{encoded_ingr}&#{@recipe_hash[:servings]}\"\n # response\n response = http.request(request)\n end",
"def new\n @lost = Lost.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @lost }\n end\n end",
"def create\n @law = Law.new(params[:law])\n\n respond_to do |format|\n if @law.save\n format.html { redirect_to @law, notice: 'Law was successfully created.' }\n format.json { render json: @law, status: :created, location: @law }\n else\n format.html { render action: \"new\" }\n format.json { render json: @law.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n render json: Loan.all\n end",
"def create\n @bill = current_user_or_guest.bills.new(bill_params)\n\n respond_to do |format|\n if @bill.save\n format.html { redirect_to(@bill, notice: t('bill.created')) }\n format.xml { render xml: @bill, status: :created, location: @bill }\n format.xml { render json: @bill, status: :created, location: @bill }\n else\n format.html { render action: \"new\" }\n format.xml { render xml: @bill.errors, status: :unprocessable_entity }\n format.xml { render json: @bill.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @knol = Knol.new(knol_params)\n\n respond_to do |format|\n if @knol.save\n format.html { redirect_to @knol, notice: 'Knol was successfully created.' }\n format.json { render action: 'show', status: :created, location: @knol }\n else\n format.html { render action: 'new' }\n format.json { render json: @knol.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(path, **args); end",
"def create\n @lbd = Lbd.new(params[:lbd])\n\n respond_to do |format|\n if @lbd.save\n format.html { redirect_to :action => 'index' }\n format.json { render json: @lbd, status: :created, location: @lbd }\n else\n format.html { render action: \"new\" }\n format.json { render json: @lbd.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @loph = Loph.new(loph_params)\n\n respond_to do |format|\n if @loph.save\n format.html { redirect_to @loph, notice: 'Loph was successfully created.' }\n format.json { render :show, status: :created, location: @loph }\n else\n format.html { render :new }\n format.json { render json: @loph.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @respuesta = Respuesta.new(params[:respuesta])\n\n if @respuesta.save\n render json: @respuesta, status: :created, location: @respuesta\n else\n render json: @respuesta.errors, status: :unprocessable_entity\n end\n end",
"def create\n @loan_servicer = LoanServicer.new(loan_servicer_params)\n\n respond_to do |format|\n if @loan_servicer.save\n format.html { redirect_to @loan_servicer, notice: 'Loan servicer was successfully created.' }\n format.json { render action: 'show', status: :created, location: @loan_servicer }\n else\n format.html { render action: 'new' }\n format.json { render json: @loan_servicer.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @loan_management = LoanManagement.new(loan_management_params)\n\n respond_to do |format|\n if @loan_management.save\n format.html { redirect_to @loan_management, notice: 'Loan management was successfully created.' }\n format.json { render :show, status: :created, location: @loan_management }\n else\n format.html { render :new }\n format.json { render json: @loan_management.errors, status: :unprocessable_entity }\n end\n end\n end",
"def loan\n @user = current_user\n @request = Request.new\n render layout: false\n end",
"def create\n @bill = Bill.new(bill_params)\n\n if @bill.save\n render json: @bill, status: :created, location: @bill\n else\n render json: @bill.errors, status: :unprocessable_entity\n end\n end",
"def post_check(excon, body)\n excon.request(\n method: :post,\n path: '/check',\n headers: { 'Content-Type' => 'application/json' },\n body: body\n )\nend",
"def create\n @webling = Webling.new(params[:webling])\n\n respond_to do |format|\n if @webling.save\n format.html { redirect_to @webling, notice: 'Webling was successfully created.' }\n format.json { render json: @webling, status: :created, location: @webling }\n else\n format.html { render action: \"new\" }\n format.json { render json: @webling.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @borrow = Borrow.new(params[:borrow])\n\n respond_to do |format|\n if @borrow.save\n format.html { redirect_to @borrow, notice: 'Borrow was successfully created.' }\n format.json { render json: @borrow, status: :created, location: @borrow }\n else\n format.html { render action: \"new\" }\n format.json { render json: @borrow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n #@lodging = Lodging.new(lodging_params)\n params.permit!\n @lodging = @travel.lodgings.new(params[:lodging])\n\n respond_to do |format|\n if @lodging.save\n #format.html { redirect_to @lodging, notice: 'Lodging was successfully created.' }\n format.html { redirect_to [@travel, @lodging], notice: 'Lodging was successfully created.' }\n format.json { render :show, status: :created, location: @lodging }\n else\n format.html { render :new }\n format.json { render json: @lodging.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(path, data = {})\n request 'POST', path, body: data.to_json\n end",
"def api_post(action, data)\n api_request(action, data, 'POST')\n end",
"def index\n @losts = Lost.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @losts }\n end\n end",
"def create\n @lk = Lk.new(lk_params)\n\n respond_to do |format|\n if @lk.save\n format.html { redirect_to @lk, notice: 'Lk was successfully created.' }\n format.json { render :show, status: :created, location: @lk }\n else\n format.html { render :new }\n format.json { render json: @lk.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @diet = Diet.new(diet_params)\n @diet.user = @current_user\n\n if @diet.save\n render json: @diet, status: 201, location: @diet, root: true\n else\n render json: @diet.errors, status: 422\n end\n end",
"def new\n @supplies_loan = SuppliesLoan.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @supplies_loan }\n end\n end",
"def post(method, **params)\n params[\"token\"] = SLACK_API_TOKEN\n json = JSON.parse(\n Net::HTTP.post_form(\n URI.parse(\"https://slack.com/api/\" + method),\n params\n ).body\n )\n return json if json[\"ok\"]\n json\n end",
"def create\n @kanban = Kanban.new(params[:kanban])\n\n respond_to do |format|\n if @kanban.save\n format.html { redirect_to(@kanban, :notice => 'Kanban was successfully created.') }\n format.xml { render :xml => @kanban, :status => :created, :location => @kanban }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @kanban.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def post!\n request! :post\n end",
"def new\n @stalking = Stalking.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @stalking }\n end\n end",
"def create\n @pinglun = Pinglun.new(comment:params[:comment],\n user:params[:user],\n shuoshuo_id:params[:shuoshuo_id])\n \n respond_to do |format|\n if @pinglun.save\n format.html { redirect_to @pinglun, notice: 'Pinglun was successfully created.' }\n format.json { render json: @pinglun, status: :created, location: @pinglun }\n else\n format.html { render action: \"new\" }\n format.json { render json: @pinglun.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @baton = Baton.new(params[:baton])\n\n respond_to do |format|\n if @baton.save\n format.html { redirect_to @baton, notice: 'Baton was successfully created.' }\n format.json { render json: @baton, status: :created, location: @baton }\n else\n format.html { render action: \"new\" }\n format.json { render json: @baton.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post(*args)\n super(*wrap_for_json_api(*args))\n end",
"def create\n @kennel_litter = KennelLitter.new(params[:kennel_litter])\n\n respond_to do |format|\n if @kennel_litter.save\n format.html { redirect_to @kennel_litter, notice: 'Kennel litter was successfully created.' }\n format.json { render json: @kennel_litter, status: :created, location: @kennel_litter }\n else\n format.html { render action: \"new\" }\n format.json { render json: @kennel_litter.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n\n @offender = User.find(params[:offender_id])\n @enforcer = current_user\n\n @ban = Ban.refined_build(params, offender: @offender, enforcer: @enforcer, jurisdiction: @cloud)\n\n if authorize @ban, :create?\n if @ban.save\n render status: 200\n set_flash_message message: \"Your target was sent to the moon.\", title: \"TO THE MOON!\"\n else\n set_flash_message message: \"You used the wrong kind of magic and the canon broke.\", title: \"Moon canon malfunction\"\n build_errors_from_model @ban\n render status: 422\n end\n else\n set_flash_message message: \"Only supreme rulers are authorized to operate the moon-canon.\", title: \"No banana bag?\"\n build_errors_from_model @ban\n render status: 401\n end\n\n end",
"def post\r\n end",
"def new\n @bottling = Bottling.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @bottling }\n end\n end",
"def create\n @lore = Lore.new(params[:lore])\n\n respond_to do |format|\n if @lore.save\n format.html { redirect_to @lore, notice: 'Lore was successfully created.' }\n format.json { render json: @lore, status: :created, location: @lore }\n else\n format.html { render action: \"new\" }\n format.json { render json: @lore.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @lodge = Lodge.new(params[:lodge])\n\n respond_to do |format|\n if @lodge.save\n format.html { redirect_to @lodge, notice: 'Lodge was successfully created.' }\n format.json { render json: @lodge, status: :created, location: @lodge }\n else\n format.html { render action: \"new\" }\n format.json { render json: @lodge.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @kishangarh_marble = KishangarhMarble.new(kishangarh_marble_params)\n\n respond_to do |format|\n if @kishangarh_marble.save\n format.html { redirect_to kishangarh_marbles_url, notice: 'Kishangarh marble was successfully created.' }\n format.json { render action: 'show', status: :created, location: @kishangarh_marble }\n else\n format.html { render action: 'new' }\n format.json { render json: @kishangarh_marble.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bingo = Bingo.new(bingo_params)\n\n respond_to do |format|\n if @bingo.save\n format.html { redirect_to @bingo, notice: \"Bingo was successfully created.\" }\n format.json { render :show, status: :created, location: @bingo }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @bingo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n\n @bans = @cloud.bans.where(\n params.select { |k,v| [:offender_id,:enforcer_id].include?(k.to_sym) }\n ).order_by(due: :desc)\n\n render status: 200\n end",
"def post; end",
"def create\n @response = Response.new\n \n reason = Reason.new\n reason.why = params[:response][:reason][:why]\n reason.critique = params[:response][:reason][:critique]\n @response.reasons = [reason]\n\n @response.who = params[:response][:who]\n @response.ip_address = request.remote_ip\n @response.user_agent = request.env['HTTP_USER_AGENT']\n\n respond_to do |format|\n if @response.save\n format.html { redirect_to root_url, notice: 'Your response was successfully submitted! Thanks for taking the time to affect change in our government.' }\n format.json { render json: @response, status: :created, location: @response }\n else\n format.html { render action: \"new\" }\n format.json { render json: @response.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @bok = Bok.new(bok_params)\n\n respond_to do |format|\n if @bok.save\n format.html { redirect_to @bok, notice: 'Bok was successfully created.' }\n format.json { render :show, status: :created, location: @bok }\n else\n format.html { render :new }\n format.json { render json: @bok.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @lager = Lager.new(lager_params)\n\n respond_to do |format|\n if @lager.save\n format.html { redirect_to @lager, notice: 'Lager was successfully created.' }\n format.json { render :show, status: :created, location: @lager }\n else\n format.html { render :new }\n format.json { render json: @lager.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @lamb_datum = LambDatum.new(lamb_datum_params)\n\n respond_to do |format|\n if @lamb_datum.save\n format.html { redirect_to @lamb_datum, notice: 'Lamb datum was successfully created.' }\n format.json { render :show, status: :created, location: @lamb_datum }\n else\n format.html { render :new }\n format.json { render json: @lamb_datum.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n\t\turi = URI.parse(Counter::Application.config.simplyurl)\n\t\thttp = Net::HTTP.new(uri.host, uri.port)\n\t\t\n\t\trequest = Net::HTTP::Post.new('/offsets.json')\n\t\tputs params\n\t\tputs params.slice(*['custids','acctids','itemids'])\n\t\t\n\t\t# ok, this join stuff is bogus - it encodes properly, but the other side only sees the last element and loses the array type - it's just string\n\t\t# this way, i 'split' it at the other side to recover my array\n\t\t# it should work without the join/split crap, but it doesn't\n\t\trequest.set_form_data({:custids => ( params['custids'] || []).join(','), :acctids => ( params['acctids'] || []).join(','), :itemids => ( params['itemids'] || []).join(','), :amount => params['amount'], :type => params['type']})\n\t\t\n\t\tputs request.body\n\t\t\n\t\tresponse = http.request(request)\n\t\tputs response.body\n\n respond_to do |format|\n format.html { render :text => response.code == :ok ? \"\" : response.body, status: response.code }\n format.json { render :text => response.code == :ok ? \"\" : response.body, status: response.code }\n end\n end",
"def create\n @potluck = Potluck.new(params[:potluck])\n\n respond_to do |format|\n if @potluck.save\n format.html { redirect_to @potluck, notice: 'Potluck was successfully created.' }\n format.json { render json: @potluck, status: :created, location: @potluck }\n else\n format.html { render action: \"new\" }\n format.json { render json: @potluck.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ballot = Ballot.new(ballot_params)\n\n respond_to do |format|\n if @ballot.save\n format.html { redirect_to ballots_url, notice: 'Thank you for voting.' }\n format.json { render :show, status: :created, location: @ballot }\n else\n format.html { render :new }\n format.json { render json: @ballot.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @lutein = Lutein.new(lutein_params)\n\n respond_to do |format|\n if @lutein.save\n format.html { redirect_to @lutein, notice: 'Lutein was successfully created.' }\n format.json { render :show, status: :created, location: @lutein }\n else\n format.html { render :new }\n format.json { render json: @lutein.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @lable = Lable.new(lable_params)\n\n respond_to do |format|\n if @lable.save\n format.html { redirect_to @lable, notice: 'Lable was successfully created.' }\n format.json { render :show, status: :created, location: @lable }\n else\n format.html { render :new }\n format.json { render json: @lable.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ledger = Ledger.new(ledger_params)\n\n respond_to do |format|\n if @ledger.save\n format.html { redirect_to @ledger, notice: 'Ledger was successfully created.' }\n format.json { render :show, status: :created, location: @ledger }\n else\n format.html { render :new }\n format.json { render json: @ledger.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @ledger = Ledger.new(ledger_params)\n\n respond_to do |format|\n if @ledger.save\n format.html { redirect_to @ledger, notice: 'Ledger was successfully created.' }\n format.json { render :show, status: :created, location: @ledger }\n else\n format.html { render :new }\n format.json { render json: @ledger.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @vote = @bet.votes.new(vote_params)\n @vote.ip_addr = params[:vote][:uuid]\n\n tmp_vote = Vote.where(ip_addr: @vote.ip_addr, bet_id: @bet.id)\n\n if @bet.ended?\n render json: {\n bet: @bet,\n error: \"EXPIRED\",\n msg: \"Bets are closed.\"\n }, status: :ok\n return\n\n elsif tmp_vote.any?\n render json: {\n status: 'error',\n error: \"ALREADY_VOTED\",\n msg: \"You've already voted on this\"\n }, status: :ok\n return\n else\n\n if @vote.answer != \"a\" and @vote.answer != \"b\"\n render json: {\n status: 'error',\n error: \"INVALID_ANSWER\",\n msg: \"Invalid answer: #{@vote.answer}\"\n }, status: :unprocessable_entity\n return\n end\n\n\n if @vote.save\n\n render json: {\n vote: @vote,\n status: \"success\",\n error: nil\n }, status: :created, location: api_v1_bet_votes_url(@bet, @vote)\n\n else\n render json: {\n status: \"error\",\n error: \"unprocessable_entity\",\n msg: @vote.errors.full_messages\n }, status: :unprocessable_entity\n end\n\n end\n\n end"
] |
[
"0.5977559",
"0.5920859",
"0.5755291",
"0.57164973",
"0.5672483",
"0.56505686",
"0.5641568",
"0.56366247",
"0.5628906",
"0.55887496",
"0.558587",
"0.5548454",
"0.55474055",
"0.55223143",
"0.5512187",
"0.54946804",
"0.54828334",
"0.5480674",
"0.5478309",
"0.5473621",
"0.54696697",
"0.54660326",
"0.54574347",
"0.5444145",
"0.5443989",
"0.54316646",
"0.5427439",
"0.54188645",
"0.5400568",
"0.5391782",
"0.53870624",
"0.5379341",
"0.53769195",
"0.53699565",
"0.53688097",
"0.5368789",
"0.53628",
"0.5357371",
"0.53552234",
"0.53548914",
"0.53541535",
"0.5346549",
"0.5318872",
"0.5312097",
"0.5310046",
"0.53027517",
"0.5294079",
"0.5292746",
"0.5289661",
"0.528766",
"0.52865213",
"0.52818847",
"0.5272427",
"0.52705604",
"0.5266313",
"0.526479",
"0.5264448",
"0.5261892",
"0.5261416",
"0.52592933",
"0.52590764",
"0.5250245",
"0.5243786",
"0.52399236",
"0.52387345",
"0.5238435",
"0.5234208",
"0.5231356",
"0.5227843",
"0.5226364",
"0.5222159",
"0.5220977",
"0.52184707",
"0.5218333",
"0.5217083",
"0.5216275",
"0.5211337",
"0.52097356",
"0.5209394",
"0.51977104",
"0.51929885",
"0.51846737",
"0.5184646",
"0.5184377",
"0.51738167",
"0.51731825",
"0.5168505",
"0.5162315",
"0.5155291",
"0.5149331",
"0.51489174",
"0.5147521",
"0.51411104",
"0.5138288",
"0.5138285",
"0.51343185",
"0.513318",
"0.5131061",
"0.5131061",
"0.5129503"
] |
0.53726566
|
33
|
PATCH/PUT /loans/1 or /loans/1.json
|
def update
respond_to do |format|
if @loan.update(loan_params)
format.html { redirect_to @loan, notice: "Loan was successfully updated." }
format.json { render :show, status: :ok, location: @loan }
else
format.html { render :edit, status: :unprocessable_entity }
format.json { render json: @loan.errors, status: :unprocessable_entity }
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update\n respond_to do |format|\n if @loan.update(loan_params)\n format.html { redirect_to @loan, notice: 'Loan was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @loan.update(loan_params)\n format.html { redirect_to @loan, notice: 'Loan was successfully updated.' }\n format.json { render :show, status: :ok, location: @loan }\n else\n format.html { render :edit }\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @loan.update(loan_params)\n format.html { redirect_to @loan, notice: 'Loan was successfully updated.' }\n format.json { render :show, status: :ok, location: @loan }\n else\n format.html { render :edit }\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @loan.update(loan_params)\n format.html { redirect_to @loan, notice: 'Loan was successfully updated.' }\n format.json { render :show, status: :ok, location: @loan }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @loanable.update(loanable_params)\n format.html { redirect_to [:users, @loanable], notice: 'Loanable was successfully updated.' }\n format.json { render :show, status: :ok, location: @loanable }\n else\n format.html { render :edit }\n format.json { render json: @loanable.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_loan\n @loan = Loan.where(id: params[:id]).first\n render json: 'not_found', status: :not_found if (@loan.nil?)\n end",
"def update\n respond_to do |format|\n if @lob.update(lob_params)\n format.html { redirect_to root_url, notice: 'Lob was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @lob.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch!\n request! :patch\n end",
"def update\n respond_to do |format|\n if @interest_on_housing_loan.update(interest_on_housing_loan_params)\n format.html { redirect_to @interest_on_housing_loan, notice: 'Interest on housing loan was successfully updated.' }\n format.json { render :show, status: :ok, location: @interest_on_housing_loan }\n else\n format.html { render :edit }\n format.json { render json: @interest_on_housing_loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @lovedone.update(lovedone_params)\n format.html { redirect_to lovedones_path, notice: 'Loved one has been successfully updated.'}\n format.json { render :show, status: :ok, location: @lovedone }\n else\n format.html { render :edit }\n format.json { render json: @lovedone.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @lomein.update(lomein_params)\n format.html { redirect_to @lomein, notice: 'Lomein was successfully updated.' }\n format.json { render :show, status: :ok, location: @lomein }\n else\n format.html { render :edit }\n format.json { render json: @lomein.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @labelling = Labelling.find(params[:id])\n\n respond_to do |format|\n if @labelling.update_attributes(params[:labelling])\n format.html { redirect_to @labelling, notice: 'Labelling was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @labelling.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @loan = Loan.find(params[:id])\n\n respond_to do |format|\n if @loan.update_attributes(params[:loan])\n flash[:notice] = 'Loan was successfully updated.'\n format.html { redirect_to(@loan) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @loan.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def api_patch(path, data = {})\n api_request(:patch, path, :data => data)\n end",
"def update\n respond_to do |format|\n if @lading.update(lading_params)\n format.html { redirect_to @lading, notice: 'Lading was successfully updated.' }\n format.json { render :show, status: :ok, location: @lading }\n else\n format.html { render :edit }\n format.json { render json: @lading.errors, status: :unprocessable_entity }\n end\n end\n end",
"def updateFromLOMAT\n respond_to do |format|\n if @tombstone_timehold.update(tombstone_timehold_params_from_lomat)\n format.html { redirect_to @tombstone_timehold, notice: 'Tombstone timehold was successfully updated.' }\n format.json { render :show, status: :ok, location: @tombstone_timehold }\n else\n format.html { render :edit }\n format.json { render json: @tombstone_timehold.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @litter = Litter.find(params[:id])\n\n respond_to do |format|\n if @litter.update_attributes(params[:litter])\n format.html { redirect_to @litter, notice: 'Litter was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @litter.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @lob = Lob.find(params[:id])\n\n if @lob.update(lob_params)\n head :no_content\n else\n render json: @lob.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @lable.update(lable_params)\n format.html { redirect_to @lable, notice: 'Lable was successfully updated.' }\n format.json { render :show, status: :ok, location: @lable }\n else\n format.html { render :edit }\n format.json { render json: @lable.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @loja = Loja.find(params[:id])\n\n respond_to do |format|\n if @loja.update_attributes(params[:loja])\n format.html { redirect_to @loja, notice: 'Loja actualizada com sucesso' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @loja.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @lobby = Lobby.find_by_id_str(params[:id])\n\n respond_to do |format|\n if @lobby.update_attributes(params[:lobby])\n format.html { redirect_to(@lobby, :notice => 'Lobby was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @lobby.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def restobooking\n @buchung = Buchung.find(params[:id])\n @buchung.status='B' \n \n respond_to do |format|\n if @buchung.update_attributes(params[:buchung])\n format.html { redirect_to @buchung, notice: 'Buchung wurde erfolgreich geaendert.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @buchung.errors, status: :unprocessable_entity }\n end\n end \n end",
"def update\n @pinglun = Pinglun.find(params[:id])\n\n respond_to do |format|\n if @pinglun.update_attributes(params[:pinglun])\n format.html { redirect_to @pinglun, notice: 'Pinglun was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @pinglun.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @loph.update(loph_params)\n format.html { redirect_to @loph, notice: 'Loph was successfully updated.' }\n format.json { render :show, status: :ok, location: @loph }\n else\n format.html { render :edit }\n format.json { render json: @loph.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @loo.update(loo_params)\n format.html { redirect_to @loo, notice: 'Loo was successfully updated.' }\n format.json { render :show, status: :ok, location: @loo }\n else\n format.html { render :edit }\n format.json { render json: @loo.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @supplies_loan = SuppliesLoan.find(params[:id])\n\n respond_to do |format|\n if @supplies_loan.update_attributes(params[:supplies_loan])\n format.html { redirect_to @supplies_loan, notice: 'Supplies loan was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @supplies_loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch\n headers = {\"If-Match\" => @version}\n response = @context.request :patch, \"#{@path}/#{@id}\", @data.to_json, headers\n @version += 1\n response\n # 'X-HTTP-Method-Override' => 'PATCH'\n end",
"def update\n respond_to do |format|\n if @loanformulary.update(loanformulary_params)\n format.html { redirect_to @loanformulary, notice: 'Loanformulary was successfully updated.' }\n format.json { render :show, status: :ok, location: @loanformulary }\n else\n format.html { render :edit }\n format.json { render json: @loanformulary.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n @laboratory = Laboratory.find(params[:id])\n\n if @laboratory.update!(laboratory_params)\n render json: @laboratory\n else \n render json: @laboratory.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @loan_type.update(loan_type_params)\n format.html { redirect_to @loan_type, notice: 'Loan type was successfully updated.' }\n format.json { render :show, status: :ok, location: @loan_type }\n else\n format.html { render :edit }\n format.json { render json: @loan_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @law = Law.find(params[:id])\n\n respond_to do |format|\n if @law.update_attributes(params[:law])\n format.html { redirect_to @law, notice: 'Law was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @law.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @loan.update(update_loan_params)\n if @loan.returned\n @tool.update(:quantity => @tool.quantity + @loan.tool_quantity)\n end\n if @loan.borrower_id = session[:student_id]\n format.html { redirect_to Student.find(@loan.borrower_id), notice: 'Loan was successfully updated.' }\n else\n format.html { redirect_to Student.find(@loan.owner_id), notice: 'Loan was successfully updated.' }\n end\n format.json { render :show, status: :ok, location: @loan }\n else\n format.html { render :edit }\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @lot = Lot.find(params[:id])\n\n respond_to do |format|\n if @lot.update_attributes(params[:lot])\n format.html { redirect_to myadmin_lots_path, :notice => 'Lot was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @lot.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @lumberjill.update(lumberjill_params)\n format.html { redirect_to @lumberjill, notice: 'Lumberjill was successfully updated.' }\n format.json { render :show, status: :ok, location: @lumberjill }\n else\n format.html { render :edit }\n format.json { render json: @lumberjill.errors, status: :unprocessable_entity }\n end\n end\n end",
"def specific\n @state = State.find(params[:id])\n @loans = @state.loans.where(:purpose_id == params[:purpose_id])\n render json: { state: @state, loans: @loans }\n end",
"def update\n respond_to do |format|\n if @loa.update(loa_params)\n format.html { redirect_to @loa, notice: 'Letter of Applicaton was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @loa.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @knol.update(knol_params)\n format.html { redirect_to @knol, notice: 'Knol was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @knol.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @lost = Lost.find(params[:id])\n\n respond_to do |format|\n if @lost.update_attributes(params[:lost])\n format.html { redirect_to @lost, notice: 'Lost was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @lost.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @boat.update(boat_params)\n head :no_content\n else\n render json: @boat.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @lodging.update(lodging_params)\n format.html { redirect_to @lodging, notice: 'Lodging was successfully updated.' }\n format.json { render :show, status: :ok, location: @lodging }\n else\n format.html { render :edit }\n format.json { render json: @lodging.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @lk.update(lk_params)\n format.html { redirect_to @lk, notice: 'Lk was successfully updated.' }\n format.json { render :show, status: :ok, location: @lk }\n else\n format.html { render :edit }\n format.json { render json: @lk.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n # if @bonus.update(bonus_params)\n # render :show, status: :ok, location: @bonus\n # else\n # render json: @bonus.errors, status: :unprocessable_entity\n # end\n end",
"def update\n @bottling = Bottling.find(params[:id])\n\n respond_to do |format|\n if @bottling.update_attributes(params[:bottling])\n format.html { redirect_to @bottling, notice: 'bottling was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @bottling.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if signed_in?\n @litra = Litra.find(params[:id])\n\n respond_to do |format|\n if @litra.update_attributes(params[:litra])\n format.html { redirect_to @litra, notice: 'Litra was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @litra.errors, status: :unprocessable_entity }\n end\n end\n end\nend",
"def update\n respond_to do |format|\n if @loan_officer.update(loan_officer_params)\n format.html { redirect_to @loan_officer, notice: 'Loan officer was successfully updated.' }\n format.json { render :show, status: :ok, location: @loan_officer }\n else\n format.html { render :edit }\n format.json { render json: @loan_officer.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @bill = Bill.find(params[:id])\n\n if @bill.update(params[:bill])\n head :no_content\n else\n render json: @bill.errors, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @loan.update(loan_params)\n format.html { redirect_to \"/loans/#{@loan.id}/#{loan_params[:next_step]}\", notice: 'Loan was successfully updated.' }\n format.json { render :show, status: :ok, location: @loan }\n else\n format.html { render :edit }\n format.json { render json: @loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @lager.update(lager_params)\n format.html { redirect_to @lager, notice: 'Lager was successfully updated.' }\n format.json { render :show, status: :ok, location: @lager }\n else\n format.html { render :edit }\n format.json { render json: @lager.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @rayon = Rayon.find(params[:id])\n\n respond_to do |format|\n if @rayon.update_attributes(params[:rayon])\n format.html { redirect_to @rayon, notice: 'Rayon was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @rayon.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @lotto.update(lotto_params)\n format.html { redirect_to @lotto, notice: 'Lotto was successfully updated.' }\n format.json { render :show, status: :ok, location: @lotto }\n else\n format.html { render :edit }\n format.json { render json: @lotto.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(path, data)\n request 'PATCH', path, body: data.to_json\n end",
"def update\n @saying = Saying.find(params[:id])\n\n respond_to do |format|\n if @saying.update_attributes(params[:saying])\n format.html { redirect_to @saying}\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @saying.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @liff.update(liff_params)\n format.html { redirect_to @liff, notice: 'Liff was successfully updated.' }\n format.json { render :show, status: :ok, location: @liff }\n else\n format.html { render :edit }\n format.json { render json: @liff.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @lodging.update(lodging_params)\n format.html { redirect_to @lodging, notice: \"Lodging was successfully updated.\" }\n format.json { render :show, status: :ok, location: @lodging }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @lodging.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @logloan.update(logloan_params)\n format.html { redirect_to @logloan, notice: 'Logloan was successfully updated.' }\n format.json { render :show, status: :ok, location: @logloan }\n else\n format.html { render :edit }\n format.json { render json: @logloan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @kennel_litter = KennelLitter.find(params[:id])\n\n respond_to do |format|\n if @kennel_litter.update_attributes(params[:kennel_litter])\n format.html { redirect_to @kennel_litter, notice: 'Kennel litter was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @kennel_litter.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @lyric.update(lyric_params)\n format.html { redirect_to @lyric, notice: 'Lyric was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @lyric.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\r\n @bill = Bill.find(params[:id])\r\n\r\n respond_to do |format|\r\n if @bill.update_attributes(params[:bill])\r\n format.html { redirect_to @bill, only_path: true, notice: 'Bill was successfully updated.' }\r\n format.json { head :no_content }\r\n else\r\n format.html { render action: \"edit\" }\r\n format.json { render json: @bill.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def update\n @bl = Bl.find(params[:id])\n\n respond_to do |format|\n if @bl.update_attributes(params[:bl])\n format.html { redirect_to @bl, notice: 'Bl was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @bl.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @bla = Bla.find(params[:id])\n\n respond_to do |format|\n if @bla.update_attributes(params[:bla])\n format.html { redirect_to @bla, :notice => 'Bla was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @bla.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @loan_management.update(loan_management_params)\n format.html { redirect_to @loan_management, notice: 'Loan management was successfully updated.' }\n format.json { render :show, status: :ok, location: @loan_management }\n else\n format.html { render :edit }\n format.json { render json: @loan_management.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @loan_log.update(loan_log_params)\n format.html { redirect_to @loan_log, notice: 'Loan log was successfully updated.' }\n format.json { render :show, status: :ok, location: @loan_log }\n else\n format.html { render :edit }\n format.json { render json: @loan_log.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @Love = Love.find(params[:id])\n\n respond_to do |format|\n if @Love.update_attributes(params[:Love])\n format.html { redirect_to @Love, :notice => 'Love was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @Love.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n if @loan.update loan_params\n redirect_to @loan\n else\n render 'edit'\n end\n end",
"def update\n respond_to do |format|\n if @lifeline.update(lifeline_params)\n format.html { redirect_to @lifeline, notice: 'Lifeline was successfully updated.' }\n format.json { render :show, status: :ok, location: @lifeline }\n else\n format.html { render :edit }\n format.json { render json: @lifeline.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @lyric = Lyric.find(params[:id])\n\n respond_to do |format|\n if @lyric.update_attributes(params[:lyric])\n format.html { redirect_to @lyric, notice: 'Lyric was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @lyric.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @lending = Lending.find(params[:id])\n\n respond_to do |format|\n if @lending.update_attributes(params[:lending])\n format.html { redirect_to @lending, :notice => 'Lending was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @lending.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @bagel.update(bagel_params)\n format.html { redirect_to @bagel, notice: 'Bagel was successfully updated.' }\n format.json { render :show, status: :ok, location: @bagel }\n else\n format.html { render :edit }\n format.json { render json: @bagel.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(path, params = {})\n request(:patch, path, params)\n end",
"def patch(path, params = {})\n request(:patch, path, params)\n end",
"def update\n @bill = Bill.find(params[:id])\n\n respond_to do |format|\n if @bill.update_attributes(params[:bill])\n format.html { redirect_to @bill, notice: 'Bill was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @bill.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @bill = Bill.find(params[:id])\n\n respond_to do |format|\n if @bill.update_attributes(params[:bill])\n format.html { redirect_to @bill, notice: 'Bill was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @bill.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @lodging = @travel.lodgings.find(params[:id])\n respond_to do |format|\n if @lodging.update(lodging_params)\n #format.html { redirect_to @lodging, notice: 'Lodging was successfully updated.' }\n format.html { redirect_to [@travel, @lodging], notice: 'Lodging was successfully updated.' }\n format.json { render :show, status: :ok, location: @lodging }\n else\n format.html { render :edit }\n format.json { render json: @lodging.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @borrow = Borrow.find(params[:id])\n\n respond_to do |format|\n if @borrow.update_attributes(params[:borrow])\n format.html { redirect_to @borrow, notice: 'Borrow was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @borrow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(path, opts = {})\n request(:patch, path, opts).body\n end",
"def update\n @player_loan = PlayerLoan.find(params[:id])\n\n respond_to do |format|\n if @player_loan.update_attributes(params[:player_loan])\n format.html { redirect_to @player_loan, notice: 'Player loan was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @player_loan.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @lodge = Lodge.find(params[:id])\n\n respond_to do |format|\n if @lodge.update_attributes(params[:lodge])\n format.html { redirect_to @lodge, notice: 'Lodge was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @lodge.errors, status: :unprocessable_entity }\n end\n end\n end",
"def rest_edit(path, options={}, &blk)\n callback = Proc.new { |*args|\n @object = yield(*args) or pass\n rest_params.each { |k, v| @object.send :\"#{k}=\", v unless k == 'id' }\n\n return 400, @object.errors.to_json unless @object.valid?\n\n @object.save\n rest_respond @object\n }\n\n # Make it work with `Backbone.emulateHTTP` on.\n put path, &callback\n post path, &callback\n end",
"def rest_edit(path, options={}, &blk)\n callback = Proc.new { |*args|\n @object = yield(*args) or pass\n rest_params.each { |k, v| @object.send :\"#{k}=\", v unless k == 'id' }\n\n return 400, @object.errors.to_json unless @object.valid?\n\n @object.save\n rest_respond @object\n }\n\n # Make it work with `Backbone.emulateHTTP` on.\n put path, &callback\n post path, &callback\n end",
"def patch options\n rest_request({ method: :patch }.merge(options))\n end",
"def patch options\n rest_request({ method: :patch }.merge(options))\n end",
"def update\n historial_params = params[:historial]\n with_bill = historial_params.delete(:with_bill)\n @historial = Historial.find(params[:id])\n\n respond_to do |format|\n if @historial.update_attributes(historial_params)\n if with_bill.present?\n format.html { redirect_to new_bill_path(\n client_id: @historial.cliente_id,\n historial_id: @historial.id\n ), notice: 'Presupuesto actualizado =)'}\n else\n format.html { redirect_to @historial, notice: 'Presupuesto actualizado =)' }\n end\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @historial.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @litigante.update(litigante_params)\n format.html { redirect_to @litigante, notice: 'Litigante was successfully updated.' }\n format.json { render :show, status: :ok, location: @litigante }\n else\n format.html { render :edit }\n format.json { render json: @litigante.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n puts \"Entró a update Nivel Mall\"\n respond_to do |format|\n if @nivel_mall.update(nivel_mall_params)\n format.html { redirect_to nivel_malls_path, notice: 'Nivel mall fue actualizado exitosamente.' }\n format.json { render :index, status: :ok, location: @nivel_mall }\n else\n format.html { render :edit }\n format.json { render json: @nivel_mall.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_api_v1_lifestyle\n @api_v1_lifestyle = Api::V1::Lifestyle.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @lutein.update(lutein_params)\n format.html { redirect_to @lutein, notice: 'Lutein was successfully updated.' }\n format.json { render :show, status: :ok, location: @lutein }\n else\n format.html { render :edit }\n format.json { render json: @lutein.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @bob = Bob.find(params[:id])\n\n respond_to do |format|\n if @bob.update_attributes(params[:bob])\n format.html { redirect_to @bob, notice: 'Bob was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @bob.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @livestock = Livestock.find(params[:id])\n\n respond_to do |format|\n if @livestock.update_attributes(params[:livestock])\n format.html { redirect_to @livestock, notice: 'Livestock was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @livestock.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @bill = current_user_or_guest.bills.find(params[:id])\n\n respond_to do |format|\n if @bill.update_attributes(bill_params)\n format.html { redirect_to(@bill, notice: t('bill.updated')) }\n format.xml { head :ok }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.xml { render xml: @bill.errors, status: :unprocessable_entity }\n format.json { render json: @bill.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @loan_servicer.update(loan_servicer_params)\n format.html { redirect_to @loan_servicer, notice: 'Loan servicer was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @loan_servicer.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @holla.update(holla_params)\n format.html { redirect_to @holla, notice: 'Holla was successfully updated.' }\n format.json { render :show, status: :ok, location: @holla }\n else\n format.html { render :edit }\n format.json { render json: @holla.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @lbd = Lbd.find(params[:id])\n\n respond_to do |format|\n if @lbd.update_attributes(params[:lbd])\n format.html { redirect_to @lbd, notice: 'Lbd was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @lbd.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @l.update(l_params)\n format.html { redirect_to @l, notice: 'L was successfully updated.' }\n format.json { render :show, status: :ok, location: @l }\n else\n format.html { render :edit }\n format.json { render json: @l.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @illust.update(illust_params)\n format.html { redirect_to @illust, notice: 'Illust was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @illust.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @plato = Plato.find(params[:id])\n\n if @plato.update(plato_params)\n head :no_content\n else\n render json: @plato.errors, status: :unprocessable_entity\n end\n end",
"def update\n begin\n balloon = Balloon.find(params[:id])\n rescue ActiveRecord::RecordNotFound => e\n balloon = nil\n end\n \n if balloon != nil && balloon.update_attributes(balloon_params) \n render json: {status: 'SUCCESS', message:'Updated balloon', data:balloon},status: :ok\n else\n render json: {status: 'ERROR', message:'Balloon not updated', data:\"balloon.error - balloon id doesnt exist\"},status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n params = lovedone_params\n r = params[:date_of_birth].split('/')\n params[:date_of_birth] = \"#{r[1]}/#{r[0]}/#{r[2]}\"\n if @lovedone.update(params)\n #format.html { redirect_to @lovedone, notice: 'Lovedone was successfully updated.' }\n flash.now[:notice] = 'Lovedone was successfully updated.'\n format.html { render :edit}\n format.json { render :show, status: :ok, location: @lovedone }\n else\n format.html { render :edit }\n format.json { render json: @lovedone.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @api_v1_initiative.update(api_v1_initiative_params)\n format.html { redirect_to @api_v1_initiative, notice: 'Initiative was successfully updated.' }\n format.json { render :show, status: :ok, location: @api_v1_initiative }\n else\n format.html { render :edit }\n format.json { render json: @api_v1_initiative.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @kela.update(kela_params)\n format.html { redirect_to @kela, notice: 'Kela was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @kela.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @livingsupply.update(livingsupply_params)\n format.html { redirect_to @livingsupply, notice: 'Livingsupply was successfully updated.' }\n format.json { render :show, status: :ok, location: @livingsupply }\n else\n format.html { render :edit }\n format.json { render json: @livingsupply.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
[
"0.62953156",
"0.61731374",
"0.61731374",
"0.61515015",
"0.60271806",
"0.60203665",
"0.59596896",
"0.5940036",
"0.5912754",
"0.5909885",
"0.5908483",
"0.59038484",
"0.59005266",
"0.58863145",
"0.5869889",
"0.5863923",
"0.5856189",
"0.58467406",
"0.5824833",
"0.58219373",
"0.5820963",
"0.5785737",
"0.5785708",
"0.57735705",
"0.5762941",
"0.5757109",
"0.573968",
"0.57178205",
"0.57168686",
"0.57046574",
"0.57032835",
"0.56942993",
"0.5690396",
"0.5682898",
"0.568241",
"0.56806356",
"0.56731856",
"0.5651665",
"0.5626962",
"0.5623136",
"0.56195724",
"0.56195134",
"0.5612964",
"0.56100816",
"0.5608157",
"0.560612",
"0.5600861",
"0.55999947",
"0.55981904",
"0.55941314",
"0.5592551",
"0.55923605",
"0.5589782",
"0.5587511",
"0.5583543",
"0.5579317",
"0.55771315",
"0.5574999",
"0.5573447",
"0.5562305",
"0.5561093",
"0.55599195",
"0.5552581",
"0.5547452",
"0.55457073",
"0.55406785",
"0.5535508",
"0.55325806",
"0.55295485",
"0.55295485",
"0.5528456",
"0.5528456",
"0.5525173",
"0.5522946",
"0.5517801",
"0.5511246",
"0.5509232",
"0.5507649",
"0.5507649",
"0.55054206",
"0.55054206",
"0.55052775",
"0.5504284",
"0.5497388",
"0.5495261",
"0.5494791",
"0.54931784",
"0.5492004",
"0.5491881",
"0.54876065",
"0.54871887",
"0.54825294",
"0.5480846",
"0.5480385",
"0.5479288",
"0.54778355",
"0.5471227",
"0.54711837",
"0.5470328",
"0.5470191"
] |
0.6154034
|
3
|
DELETE /loans/1 or /loans/1.json
|
def destroy
@loan.destroy
respond_to do |format|
format.html { redirect_to loans_url, notice: "Loan was successfully destroyed." }
format.json { head :no_content }
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def destroy\n @loan.destroy\n respond_to do |format|\n format.html { redirect_to loans_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @loan.destroy\n respond_to do |format|\n format.html { redirect_to loans_url, notice: 'Loan was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @loan.destroy\n respond_to do |format|\n format.html { redirect_to loans_url, notice: 'Loan was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @loan.destroy\n respond_to do |format|\n format.html { redirect_to loans_url, notice: 'Loan was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @loan = Loan.find(params[:id])\n @loan.destroy\n\n respond_to do |format|\n format.html { redirect_to(loans_url) }\n format.xml { head :ok }\n end\n end",
"def delete\n client.delete(\"/#{id}\")\n end",
"def destroy\n @baton = Baton.find(params[:id])\n @baton.destroy\n\n respond_to do |format|\n format.html { redirect_to batons_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @pinglun = Pinglun.find(params[:id])\n @pinglun.destroy\n\n respond_to do |format|\n format.html { redirect_to pingluns_url }\n format.json { head :no_content }\n end\n end",
"def delete\n render json: Alien.delete(params[\"id\"])\n end",
"def destroy\n @loanable.destroy\n respond_to do |format|\n format.html { redirect_to users_loanables_url, notice: 'Loanable was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @lore = Lore.find(params[:id])\n @lore.destroy\n\n respond_to do |format|\n format.html { redirect_to lores_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @logloan.destroy\n respond_to do |format|\n format.html { redirect_to logloans_url, notice: 'Logloan was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @lob.destroy\n respond_to do |format|\n format.html { redirect_to root_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @law = Law.find(params[:id])\n @law.destroy\n\n respond_to do |format|\n format.html { redirect_to laws_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @lent = Lent.find(params[:id])\n @lent.destroy\n\n respond_to do |format|\n format.html { redirect_to lents_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @law = Law.find(params[:id])\n @law.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_laws_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @loan = Loan.find(params[:id])\n helper_book_false Book.find(@loan.book_id)\n @loan.destroy\n\n respond_to do |format|\n format.html { redirect_to loans_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @supplies_loan = SuppliesLoan.find(params[:id])\n @supplies_loan.destroy\n\n respond_to do |format|\n format.html { redirect_to supplies_loans_url }\n format.json { head :no_content }\n end\n end",
"def delete path\n make_request(path, \"delete\", {})\n end",
"def destroy\n @loja = Loja.find(params[:id])\n @loja.destroy\n\n respond_to do |format|\n format.html { redirect_to lojas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @loan_log.destroy\n respond_to do |format|\n format.html { redirect_to loan_logs_url, notice: 'Loan log was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete!( opts = {} )\n http_action :delete, nil, opts\n end",
"def deletes_to(path,opts={},&block) #:nodoc: \n crud_to(:delete,path,opts[:params] || {},opts,&block)\n end",
"def destroy\n @loan_type.destroy\n respond_to do |format|\n format.html { redirect_to loan_types_url, notice: 'Loan type was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @player_loan = PlayerLoan.find(params[:id])\n @player_loan.destroy\n\n respond_to do |format|\n format.html { redirect_to player_loans_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @interest_on_housing_loan.destroy\n respond_to do |format|\n format.html { redirect_to interest_on_housing_loans_url, notice: 'Interest on housing loan was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @hal = Hal.find(params[:id])\n @hal.destroy\n\n respond_to do |format|\n format.html { redirect_to \"/hals/view_mine\" }\n format.json { head :no_content }\n end\n end",
"def delete_tenant_circle(args = {}) \n delete(\"/tenantcircles.json/#{args[:circleId]}\", args)\nend",
"def destroy\n @walikela.destroy\n respond_to do |format|\n format.html { redirect_to walikelas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @knol.destroy\n respond_to do |format|\n format.html { redirect_to knols_url }\n format.json { head :no_content }\n end\n end",
"def delete(name)\n raise('wrong type: String required') unless name.is_a?(String)\n raise('wrong value: name must be valid') unless !name.nil? && !name.empty?\n\n @client.post({\n 'action' => 'del',\n 'object' => 'htpl',\n 'values' => name,\n }.to_json)\n end",
"def destroy\r\n @bill = Bill.find(params[:id])\r\n @bill.destroy\r\n\r\n respond_to do |format|\r\n format.html { redirect_to bills_url, only_path: true }\r\n format.json { head :no_content }\r\n end\r\n end",
"def destroy\n @lodging.destroy\n respond_to do |format|\n format.html { redirect_to lodgings_url, notice: \"Lodging was successfully destroyed.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @rayon = Rayon.find(params[:id])\n @rayon.destroy\n\n respond_to do |format|\n format.html { redirect_to rayons_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bla = Bla.find(params[:id])\n @bla.destroy\n\n respond_to do |format|\n format.html { redirect_to blas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @lodging.destroy\n respond_to do |format|\n format.html { redirect_to lodgings_url, notice: 'Lodging was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @release_loan = ReleaseLoan.find(params[:id])\n @release_loan.destroy\n\n respond_to do |format|\n format.html { redirect_to release_loans_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @natulang = Natulang.find(params[:id])\n @natulang.destroy\n\n respond_to do |format|\n format.html { redirect_to natulangs_url }\n format.json { head :no_content }\n end\n \n end",
"def delete\n request(:delete)\n end",
"def delete\n url = prefix + \"delete\" + id_param\n return response(url)\n end",
"def destroy\n animal = Animal.find(params[:id])\n animal.destroy\n head 204\n end",
"def destroy\n @lobby = Lobby.find_by_id_str(params[:id])\n @lobby.destroy\n\n respond_to do |format|\n format.html { redirect_to(lobbies_url) }\n format.xml { head :ok }\n end\n end",
"def delete_aos_version(args = {}) \n delete(\"/aosversions.json/#{args[:aosVersionId]}\", args)\nend",
"def destroy\n @historial = Historial.find(params[:id])\n @historial.destroy\n\n respond_to do |format|\n format.html { redirect_to historials_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @lomein.destroy\n respond_to do |format|\n format.html { redirect_to lomeins_url, notice: 'Lomein was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ramal = Ramal.find(params[:id])\n @ramal.destroy\n\n respond_to do |format|\n format.html { redirect_to ramais_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @human = Human.find(params[:id])\n @human.destroy\n\n respond_to do |format|\n format.html { redirect_to humans_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @loan_servicer.destroy\n respond_to do |format|\n format.html { redirect_to loan_servicers_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @lector = Lector.find(params[:id])\n @lector.destroy\n\n respond_to do |format|\n format.html { redirect_to lectores_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @kishangarh_marble.destroy\n respond_to do |format|\n format.html { redirect_to kishangarh_marbles_url }\n format.json { head :no_content }\n end\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 destroy\n @hotele = Hotele.find(params[:id])\n @hotele.destroy\n\n respond_to do |format|\n format.html { redirect_to hoteles_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @tangent.destroy\n respond_to do |format|\n format.html { redirect_to tangents_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @kota_stone.destroy\n respond_to do |format|\n format.html { redirect_to kota_stones_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bottling = Bottling.find(params[:id])\n @bottling.destroy\n\n respond_to do |format|\n format.html { redirect_to bottlings_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @one = One.find(params[:id])\n @one.destroy\n\n respond_to do |format|\n format.html { redirect_to ones_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @smsloan.destroy\n respond_to do |format|\n format.html { redirect_to smsloans_url, notice: 'Smsloan was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @kehadiran.destroy\n respond_to do |format|\n format.html { redirect_to kehadirans_url, notice: 'Kehadiran was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @leito = Leito.find(params[:id])\n @leito.destroy\n\n respond_to do |format|\n format.html { redirect_to leitos_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @loan_emi.destroy\n respond_to do |format|\n format.html { redirect_to loan_emis_url, notice: 'Loan emi was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n laboratory_id = params[:id]\n\n begin\n @laboratory = Laboratory.find(laboratory_id)\n\n @laboratory.delete if @laboratory.status == true\n render json: \"#{@laboratory.nome} deletado com sucesso!\"\n\n rescue ActiveRecord::RecordNotFound\n render json: 'esse dado já foi deletado!'\n end\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def delete\n url = prefix + \"delete\"\n return response(url)\n end",
"def destroy\n @human = Human.find(params[:id])\n @human.destroy\n\n respond_to do |format|\n format.html { redirect_to humen_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mostsmallmission = Mostsmallmission.find(params[:id])\n @mostsmallmission.destroy\n\n respond_to do |format|\n format.html { redirect_to mostsmallmissions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mall = Mall.find(params[:id])\n @mall.destroy\n\n respond_to do |format|\n format.html { redirect_to malls_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @l.destroy\n respond_to do |format|\n format.html { redirect_to ls_url, notice: 'L was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bill.destroy\n respond_to do |format|\n format.html { redirect_to bills_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bill.destroy\n respond_to do |format|\n format.html { redirect_to bills_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bill.destroy\n\n respond_to do |format|\n format.html { redirect_to bills_path }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ally.destroy\n respond_to do |format|\n format.html { redirect_to allies_url, notice: 'Ally was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ally.destroy\n respond_to do |format|\n format.html { redirect_to allies_url, notice: 'Ally was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @lovedone.destroy\n respond_to do |format|\n #refresh \n format.html { redirect_to lovedones_url, notice: 'Loved one has been successfully deleted.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @borrow = Borrow.find(params[:id])\n @borrow.destroy\n\n respond_to do |format|\n format.html { redirect_to borrows_url }\n format.json { head :ok }\n end\n end",
"def destroy\n \n @loph.destroy\n respond_to do |format|\n format.html { redirect_to lophs_url, notice: 'Loph was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bahan = Bahan.find(params[:id])\n @bahan.destroy\n\n respond_to do |format|\n format.html { redirect_to bahans_url }\n format.json { head :no_content }\n end\n end",
"def delete(path, params)\n headers = {:Authorization => \"token #{token}\", :content_type => :json, :accept => :json}\n res = RestClient.delete(\"#{github_api_uri}/#{path}\", params.to_json, headers)\n Yajl.load(res)\n end",
"def destroy\n @bill = Bill.find(params[:id])\n @bill.destroy\n\n respond_to do |format|\n format.html { redirect_to bills_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bill = Bill.find(params[:id])\n @bill.destroy\n\n respond_to do |format|\n format.html { redirect_to bills_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bill = Bill.find(params[:id])\n @bill.destroy\n\n respond_to do |format|\n format.html { redirect_to bills_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n if @diet.destroy\n head :no_content, status: 200\n else\n render json: @diet.errors, status: 405\n end\n end",
"def destroy\n @kela.destroy\n respond_to do |format|\n format.html { redirect_to kelas_url }\n format.json { head :no_content }\n end\n end",
"def delete\n render json: Like.delete(params[\"id\"])\n end",
"def destroy\n @makrana_marble.destroy\n respond_to do |format|\n format.html { redirect_to makrana_marbles_url }\n format.json { head :no_content }\n end\n end",
"def delete!\n request! :delete\n end",
"def destroy\n @lading.destroy\n respond_to do |format|\n format.html { redirect_to ladings_url, notice: 'Lading was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @v1_chore = Chore.where(id: params[:id])\n if @v1_chore.destroy\n head(:ok)\n else\n head(:unprocessable_entity)\n end\n end",
"def destroy\n @saying = Saying.find(params[:id])\n @saying.destroy\n\n respond_to do |format|\n format.html { redirect_to sayings_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @lode.destroy\n respond_to do |format|\n format.html { redirect_to lodes_url, notice: 'Lode was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @jamaat = Jamaat.find(params[:id])\n @jamaat.destroy\n\n respond_to do |format|\n format.html { redirect_to jamaats_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @lk.destroy\n respond_to do |format|\n format.html { redirect_to lks_url, notice: 'Lk was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete\n supprimer = SondageService.instance.supprimerSondage(params[:id])\n (supprimer) ? (render json: true, status: :ok) : (render json: false, status: :not_found)\nend",
"def destroy\n @lot = Lot.find(params[:id])\n @lot.destroy\n\n respond_to do |format|\n format.html { redirect_to myadmin_lots_url }\n format.json { head :no_content }\n end\n end",
"def test_del\n header 'Content-Type', 'application/json'\n\n data = File.read 'sample-traces/0.json'\n post('/traces', data, 'CONTENT_TYPE': 'application/json')\n\n id = last_response.body\n\n delete \"/traces/#{id}\"\n assert last_response.ok?\n\n get \"/traces/#{id}\"\n\n contents = JSON.parse last_response.body\n assert_kind_of(Hash, contents, 'Response contents is not a hash')\n assert contents.key? 'description'\n assert(!last_response.ok?)\n end",
"def destroy\n @theader.destroy\n respond_to do |format|\n format.html { redirect_to offices_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @law.destroy\n respond_to do |format|\n format.html { redirect_to laws_url, notice: 'Law was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @law.destroy\n respond_to do |format|\n format.html { redirect_to laws_url, notice: 'Law was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @home_loan.destroy\n respond_to do |format|\n format.html { redirect_to home_loans_url, notice: 'Home loan was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n if signed_in?\n @litra = Litra.find(params[:id])\n @litra.destroy\n\n respond_to do |format|\n format.html { redirect_to litras_url }\n format.json { head :no_content }\n end\n end\nend",
"def destroy\n @roof = Roof.find(params[:roof_id])\n @status = @roof.statuses.find(params[:id])\n @status.destroy\n\n respond_to do |format|\n format.html { redirect_to statuseses_url }\n format.json { head :no_content }\n end\n end"
] |
[
"0.7036163",
"0.67780507",
"0.67780507",
"0.67780507",
"0.6766855",
"0.66537154",
"0.6653622",
"0.6645782",
"0.6631344",
"0.6608415",
"0.65562505",
"0.65418816",
"0.6501577",
"0.64719397",
"0.64577454",
"0.6455477",
"0.6452458",
"0.6449015",
"0.6442445",
"0.6441725",
"0.6439765",
"0.6428547",
"0.64222497",
"0.6408425",
"0.64055973",
"0.64026517",
"0.63934654",
"0.6388375",
"0.6355333",
"0.6354111",
"0.63262206",
"0.6322659",
"0.63200575",
"0.63194805",
"0.63178325",
"0.6314007",
"0.63093233",
"0.630908",
"0.63031083",
"0.63024646",
"0.63001287",
"0.6297673",
"0.6289668",
"0.6286855",
"0.628503",
"0.6282492",
"0.6281006",
"0.6277118",
"0.6275767",
"0.627537",
"0.6268533",
"0.6267231",
"0.626363",
"0.62605023",
"0.62586856",
"0.6256509",
"0.62517124",
"0.6250393",
"0.6249888",
"0.6248541",
"0.6246284",
"0.6244439",
"0.6244439",
"0.62416154",
"0.6238344",
"0.6235539",
"0.6234179",
"0.6229853",
"0.6229853",
"0.6229134",
"0.62265307",
"0.62265307",
"0.6222686",
"0.62214357",
"0.62205595",
"0.6218543",
"0.6217981",
"0.6216294",
"0.6216294",
"0.6216294",
"0.6214937",
"0.62147605",
"0.6213046",
"0.621156",
"0.62109804",
"0.6209899",
"0.6206915",
"0.6205487",
"0.6205096",
"0.620154",
"0.62009895",
"0.6199844",
"0.61983615",
"0.6196509",
"0.61944616",
"0.6194019",
"0.6194019",
"0.6192588",
"0.61925566",
"0.6191795"
] |
0.6769833
|
4
|
Use callbacks to share common setup or constraints between actions.
|
def set_loan
@loan = Loan.find(params[:id])
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def setup_handler\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def workflow\n end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup\n # override and do something appropriate\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def before_action \n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def setup_signals; end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def initialize(*args)\n super\n @action = :set\nend",
"def after_set_callback; end",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def around_hooks; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def duas1(action)\n action.call\n action.call\nend",
"def shared_action(name, &block)\n @controller.shared_actions[name] = block\n end",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] |
[
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576",
"0.53124547",
"0.529654",
"0.5296262",
"0.52952296",
"0.52600986",
"0.52442724",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.5232394",
"0.523231",
"0.5227454",
"0.52226824",
"0.52201617",
"0.5212327",
"0.52079266",
"0.52050185",
"0.51754695",
"0.51726824",
"0.51710224",
"0.5166172",
"0.5159343",
"0.51578903",
"0.51522785",
"0.5152022",
"0.51518047",
"0.51456624",
"0.51398855",
"0.5133759",
"0.5112076",
"0.5111866",
"0.5111866",
"0.5110294",
"0.5106169",
"0.509231",
"0.50873137",
"0.5081088",
"0.508059",
"0.50677156",
"0.50562143",
"0.5050554",
"0.50474834",
"0.50474834",
"0.5036181",
"0.5026331",
"0.5022976",
"0.5015441",
"0.50121695",
"0.5000944",
"0.5000019",
"0.4996878",
"0.4989888",
"0.4989888",
"0.49864885",
"0.49797225",
"0.49785787",
"0.4976161",
"0.49683493",
"0.4965126",
"0.4958034",
"0.49559742",
"0.4954353",
"0.49535993",
"0.4952725",
"0.49467874",
"0.49423352",
"0.49325448",
"0.49282882",
"0.49269363",
"0.49269104",
"0.49252945",
"0.4923091",
"0.49194667",
"0.49174926",
"0.49173003",
"0.49171105",
"0.4915879",
"0.49155936"
] |
0.0
|
-1
|
Only allow a list of trusted parameters through.
|
def loan_params
params.require(:loan).permit(:book_id, :start_date, :end_date)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def allowed_params\n ALLOWED_PARAMS\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def parameters_list_params\n params.require(:parameters_list).permit(:name, :description, :is_user_specific)\n end",
"def param_whitelist\n [:role, :title]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def allow_params_authentication!; end",
"def whitelisted_args\n args.select &:allowed\n end",
"def safe_list_sanitizer; end",
"def safe_list_sanitizer; end",
"def safe_list_sanitizer; end",
"def filtered_parameters; end",
"def sanitize_params_for user, params, allowed_params\n params.each do |key, val|\n #if allowed_params.include?(key)\n #sanitize!(user, params, key) if key =~ /_attributes|_ids$/\n #else\n #params.delete(key)\n #end\n params.delete(key) unless allowed_params.include?(key.to_sym)\n end\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def expected_permitted_parameter_names; end",
"def sanitize_parameters!(sanitizer, params)\n # replace :readwrite with :onlyif\n if params.has_key?(:readwrite)\n warn \":readwrite is deprecated. Replacing with :onlyif\"\n params[:onlyif] = params.delete(:readwrite)\n end\n\n # add default parameters\n bindata_default_parameters.each do |k,v|\n params[k] = v unless params.has_key?(k)\n end\n\n # ensure mandatory parameters exist\n bindata_mandatory_parameters.each do |prm|\n if not params.has_key?(prm)\n raise ArgumentError, \"parameter ':#{prm}' must be specified \" +\n \"in #{self}\"\n end\n end\n\n # ensure mutual exclusion\n bindata_mutually_exclusive_parameters.each do |param1, param2|\n if params.has_key?(param1) and params.has_key?(param2)\n raise ArgumentError, \"params #{param1} and #{param2} \" +\n \"are mutually exclusive\"\n end\n end\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_list_sanitizer=(_arg0); end",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def check_params; true; end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def allowed?(*_)\n true\n end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def allowed_params(parameters)\n parameters.select do |name, values|\n values.location != \"path\"\n end\n end",
"def secure_params\n return @secure_params if @secure_params\n\n defn = implementation_class.definition\n field_list = [:master_id] + defn.field_list_array\n\n res = params.require(controller_name.singularize.to_sym).permit(field_list)\n res[implementation_class.external_id_attribute.to_sym] = nil if implementation_class.allow_to_generate_ids?\n @secure_params = res\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permit( params, whitelist, name = nil )\n raise 'Parametrization not yet configured' unless @configured\n whitelist ||= []\n px = params.respond_to?( :permit ) ? params : ActionController::Parameters.new( params )\n px = dig(px, name)\n px.permit( *whitelist )\n end",
"def valid_params?; end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def url_allowlist=(_arg0); end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def list_params\n params.permit(:list_name)\n end",
"def valid_params_request?; end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def param_list(param_type, name, type, required, description = nil, allowed_values = [], hash = {})\n hash.merge!({allowable_values: {value_type: \"LIST\", values: allowed_values}})\n param(param_type, name, type, required, description, hash)\n end",
"def safelists; end",
"def authorize_own_lists\n authorize_lists current_user.lists\n end",
"def listed_params\n params.permit(:listed, :list_id, :listable_id, :listable_type, :campsite_id)\n end",
"def lists_params\n params.require(:list).permit(:name)\n\n end",
"def list_params\n params.require(:list).permit(:name, :user_id)\n end",
"def list_params\n params.require(:list).permit(:name, :description, :type, :privacy, :allow_edit, :rating, :votes_count, :user_id)\n end",
"def check_params\n true\n end",
"def authorize_own_or_shared_lists\n authorize_lists current_user.all_lists\n end",
"def user_pref_list_params\n\t\tparams.require(:user).permit(:preference_list)\n\tend",
"def may_contain!(*keys)\n self.allow_only_permitted = true\n self.permitted_keys = [*permitted_keys, *keys].uniq\n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def whitelist; end",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.permit(:name)\n end",
"def recipient_list_params\n params.require(:recipient_list).permit(:name, :list, :references)\n end",
"def cancan_parameter_sanitizer\n resource = controller_name.singularize.to_sym\n method = \"#{resource}_params\"\n params[resource] &&= send(method) if respond_to?(method, true)\n end",
"def list_params\n params.require(:list).permit(:name).merge(user_id: current_user.id)\n end",
"def whitelist_place_params\n params.require(:place).permit(:place_name, :unlock, :auth, :is_deep_checked, :parent_ADM4, :parent_ADM3, :parent_ADM2, :parent_ADM1, :parent_country, feature_code: [], same_as: [], related_authority: [], altlabel: [], note: []) # Note - arrays need to go at the end or an error occurs!\n end",
"def list_params\n params.fetch(:list, {}).permit(:user_id, :name, :active)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def secure_params(require_param, permit_keys)\n params.require(require_param).permit(*permit_keys)\n end",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def permitted_params\n []\n end",
"def price_list_params\n params.fetch(:price_list, {}).permit(:name, :valid_from, :valid_to, :active,\n :all_warehouses, :all_users, :all_contact_groups,\n warehouse_ids: [], price_lists_user_ids: [], contact_group_ids: [])\n end",
"def params(list)\n @declared_params = list\n end",
"def admin_review_params\n params.fetch(:review, {}).permit(whitelisted_params)\n end",
"def saved_list_params\n params.require(:saved_list).permit(:user_id)\n end",
"def allow(ids); end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def filter_params(param_set, **kwargs)\r\n begin\r\n key = kwargs[:key]\r\n params.require(key).permit(*param_set)\r\n rescue Exception\r\n params.permit(*param_set)\r\n end\r\n end",
"def valid_parameters\n sort_symbols(@interface.allowed_parameters)\n end",
"def validate_paramified_params\n self.class.paramify_methods.each do |method|\n params = send(method)\n transfer_errors_from(params, TermMapper.scope(params.group)) if !params.valid?\n end\n end",
"def list_params\n params.require(:list).permit(:name)\n end",
"def secure_params\n return @secure_params if @secure_params\n\n @implementation_class = implementation_class\n resname = @implementation_class.name.ns_underscore.gsub('__', '_').singularize.to_sym\n @secure_params = params.require(resname).permit(*permitted_params)\n end",
"def refine_permitted_params(param_list)\n res = param_list.dup\n\n ms_keys = res.select { |a| columns_hash[a.to_s]&.array }\n ms_keys.each do |k|\n res.delete(k)\n res << { k => [] }\n end\n\n res\n end",
"def recipient_list_params\n params.require(:recipient_list).permit(:name, :description, recipient_id_array: [])\n end",
"def safelist; end",
"def sponsor_params\n params.require(:sponsor).permit(WHITE_LIST)\n end",
"def valid_for_params_auth?; end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def shopping_list_params\n params.require(:shopping_list).permit!\n end",
"def permitted_params\n declared(params, include_missing: false)\n end",
"def permitted_params\n declared(params, include_missing: false)\n end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def permitters\n @_parametrizr_permitters || {}\n end",
"def allow_params(action, keys: nil, except: nil, &blk)\n keys &&= Array.wrap(keys)\n keys ||= User.field_names\n except &&= Array.wrap(except)\n except ||= %i[id email]\n devise_parameter_sanitizer.permit(action, keys: keys, except: except, &blk)\n end",
"def list_params\n if current_user && current_user.role == 'admin'\n params.require(:list).permit(:name, :url, :description, :user_id,\n ideas_attributes: [:id, :list_id, :body, :due_date, :completion_status, :_destroy])\n else\n params.require(:list).permit(:name, :description,\n ideas_attributes: [:body, :due_date, :completion_status]) \n end\n end",
"def whitelist(params)\n send_request_of_type(GlobalConstant::PrivateOpsApi.private_ops_api_type, 'post', '/token-sale/whitelist', params)\n end",
"def valid_access_params\n params.require(:valid_access).permit(:wish_list_id, :user_id)\n end",
"def url_allowlist; end",
"def ensure_redirected_params_are_safe!(passed_params)\n unless passed_params.is_a?(ActionController::Parameters) && passed_params.permitted?\n error_message = if passed_params.is_a?(ActionController::Parameters)\n unsafe_parameters = passed_params.send(:unpermitted_keys, params)\n \"[Rails::Prg] Error - Must use permitted strong parameters. Unsafe: #{unsafe_parameters.join(', ')}\"\n else\n \"[Rails::Prg] Error - Must pass strong parameters.\"\n end\n raise error_message\n end\n end",
"def data_collection_params\n allow = [:name,:description,:institution,:collection_name,:country_id,:province_id,:city_id]\n params.require(:data_collection).permit(allow)\n end",
"def quote_params\n params.permit!\n end"
] |
[
"0.69497335",
"0.6812623",
"0.6803639",
"0.6795365",
"0.67448795",
"0.67399913",
"0.6526815",
"0.6518771",
"0.64931697",
"0.6430388",
"0.6430388",
"0.6430388",
"0.63983387",
"0.6356042",
"0.63535863",
"0.63464934",
"0.63444513",
"0.6337208",
"0.6326454",
"0.6326454",
"0.6326454",
"0.63140553",
"0.6299814",
"0.62642586",
"0.626006",
"0.62578833",
"0.6236823",
"0.6227561",
"0.6221758",
"0.62200165",
"0.620879",
"0.61983657",
"0.6195055",
"0.6172993",
"0.6156856",
"0.61558664",
"0.61521494",
"0.6135789",
"0.6121145",
"0.61118174",
"0.60736513",
"0.6071645",
"0.60632104",
"0.60549796",
"0.6043906",
"0.6034662",
"0.60207325",
"0.6018568",
"0.6016575",
"0.60103434",
"0.60084206",
"0.600763",
"0.6007443",
"0.6003619",
"0.6003619",
"0.5995791",
"0.5993301",
"0.5993231",
"0.5984926",
"0.597122",
"0.5968121",
"0.5965808",
"0.59640145",
"0.59632224",
"0.59602356",
"0.59332967",
"0.5927556",
"0.5922805",
"0.5909745",
"0.5905083",
"0.5904304",
"0.5893434",
"0.58888215",
"0.58823985",
"0.58823985",
"0.58823985",
"0.5873434",
"0.58619875",
"0.58533794",
"0.5845531",
"0.58426666",
"0.58360124",
"0.583218",
"0.5828041",
"0.5827927",
"0.5816121",
"0.5814705",
"0.5812719",
"0.581121",
"0.5803423",
"0.5803423",
"0.57995003",
"0.5794207",
"0.5784923",
"0.5781365",
"0.5776385",
"0.5774859",
"0.57671493",
"0.5766998",
"0.57618684",
"0.5758038"
] |
0.0
|
-1
|
==== Parameters: +options+:: Hash of options ==== Options: +access_key_id+:: access key id +secret_access_key+:: secret access key +use_ssl+:: optional, defaults to false +debug+:: optional, defaults to false +timeout+:: optional, for Net::HTTP
|
def initialize(options = {})
@access_key_id = options[:access_key_id]
@secret_access_key = options[:secret_access_key]
@use_ssl = options[:use_ssl] || false
@debug = options[:debug]
@timeout = options[:timeout]
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def initialize(options)\n @access_key_id = options[:access_key_id] or raise ArgumentError, \"No access key id given\"\n @secret_access_key = options[:secret_access_key] or raise ArgumentError, \"No secret access key given\"\n @use_ssl = options[:use_ssl]\n @timeout = options[:timeout]\n @debug = options[:debug]\n end",
"def request(options)\n raise HyvesException, 'You need an access token to make requests' if access_token.nil?\n options = default_request_options.merge(options)\n access_token.post('/', options)\n end",
"def send_request(options)\n\n # construct our RESTful request URI\n uri = \"#{Base.base_uri}/api/#{options[:target]}\"\n uri += \"/#{options[:id]}\" if options.has_key?(:id)\n uri += \"/#{options[:what]}\" if options.has_key?(:what)\n uri += \".#{options[:how]}\" if options[:method] == \"get\"\n puts \"|--------------------- SEND_REQUEST ---------------------|\"\n puts \"| URI\"\n puts \"| #{uri}\"\n puts \"| Params\"\n puts \"| id => #{options[:id]}\"\n puts \"| what => #{options[:what]}\"\n puts \"| how => #{options[:how]}\"\n puts \"|--------------------- ------------ ---------------------|\"\n \n if @access_token.nil? \n return self.class.send(options[:method] || \"get\", uri, options)\n else\n return @access_token.send(options[:method] || \"get\", uri, options).body\n end\n \n end",
"def initialize(options = nil)\n @options = options || @@default_options\n @api_key = @options[:api_key] || @options[:oauth_consumer_key]\n @shared_secret = @options[:shared_secret]\n @rest_endpoint = @options[:rest_endpoint] || REST_ENDPOINT\n @auth_endpoint = @options[:auth_endpoint] || AUTH_ENDPOINT\n \n if @options[:oauth_access_token] && @options[:oauth_access_token_secret]\n @access_token = OAuth::AccessToken.new(oauth_customer, @options[:oauth_access_token], @options[:oauth_access_token_secret])\n end\n end",
"def sign_request(options)\n options.merge!(:pub => @api_key)\n options.merge!(:key => Digest::MD5.hexdigest(@api_secret + @api_key))\n end",
"def initialize(options = {})\n\n @public_key = options[:public_key]\n if @public_key == nil\n @public_key = Simplify::public_key\n end\n\n @private_key = options[:private_key]\n if private_key == nil\n @private_key = Simplify::private_key\n end\n\n @access_token = options[:access_token]\n end",
"def fetch_access_token options = {}\n c = options[:connection] || Faraday.default_connection\n retry_with_error do\n uri = target_audience ? COMPUTE_ID_TOKEN_URI : COMPUTE_AUTH_TOKEN_URI\n query = target_audience ? { \"audience\" => target_audience, \"format\" => \"full\" } : nil\n headers = { \"Metadata-Flavor\" => \"Google\" }\n resp = c.get uri, query, headers\n case resp.status\n when 200\n content_type = resp.headers[\"content-type\"]\n if content_type == \"text/html\"\n { (target_audience ? \"id_token\" : \"access_token\") => resp.body }\n else\n Signet::OAuth2.parse_credentials resp.body, content_type\n end\n when 404\n raise Signet::AuthorizationError, NO_METADATA_SERVER_ERROR\n else\n msg = \"Unexpected error code #{resp.status}\" \\\n \"#{UNEXPECTED_ERROR_SUFFIX}\"\n raise Signet::AuthorizationError, msg\n end\n end\n end",
"def connect(options)\n o = options.slice(:access_key_id, :secret_access_key, :server, :port, :use_ssl, :persistent, :proxy)\n AWS::S3::Base.establish_connection!(o.dup) # establish_connection! modifies the hash\n @connection_options = o\n end",
"def http_options time = nil\n config_valid?\n ts = (time || Time.new).to_i.to_s\n digest = OpenSSL::Digest::SHA1.hexdigest(@configuration.shared_secret + ts)\n {\n api_key: @configuration.api_key,\n ts: ts,\n hash: digest\n }\n end",
"def request(path, options={})\n response = @connection.get do |req|\n req.url path\n req.params[:api_key] = @access_token\n options.each do |key, val|\n req.params[key] = val\n end\n end\n response.body\n end",
"def initialize options = {}\n @authorization_uri = nil\n @token_credential_uri = nil\n @client_id = nil\n @client_secret = nil\n @code = nil\n @expires_at = nil\n @issued_at = nil\n @issuer = nil\n @password = nil\n @principal = nil\n @redirect_uri = nil\n @scope = nil\n @target_audience = nil\n @state = nil\n @username = nil\n @access_type = nil\n update! options\n end",
"def initialize(options={})\n @debug_dev = options[:debug_dev]\n @autodiscover_url = options[:autodiscover_url]\n\n @http = HTTPClient.new\n @http.force_basic_auth = true # Saves one unathenticated request\n @http.connect_timeout = options[:connect_timeout] || CONNECT_TIMEOUT_DEFAULT\n @http.debug_dev = @debug_dev if @debug_dev\n\n @redirect_count = 0\n end",
"def oauth_options\n {\n consumer_key: client_id,\n consumer_secret: client_secret,\n token: access_token,\n token_secret: access_token_secret\n }\n end",
"def initialize(options={})\n # Client auth configuration\n @flow = options[:flow] || options.keys.first.to_s || 'web'\n fdata = options[@flow.to_sym] || options[@flow]\n @client_id = fdata[:client_id] || fdata[\"client_id\"]\n @client_secret = fdata[:client_secret] || fdata[\"client_secret\"]\n @redirect_uris = fdata[:redirect_uris] || fdata[\"redirect_uris\"]\n @redirect_uris ||= [fdata[:redirect_uri] || fdata[\"redirect_uri\"]].compact\n @javascript_origins = (\n fdata[:javascript_origins] ||\n fdata[\"javascript_origins\"]\n )\n @javascript_origins ||= [fdata[:javascript_origin] || fdata[\"javascript_origin\"]].compact\n @authorization_uri = fdata[:auth_uri] || fdata[\"auth_uri\"]\n @authorization_uri ||= fdata[:authorization_uri]\n @token_credential_uri = fdata[:token_uri] || fdata[\"token_uri\"]\n @token_credential_uri ||= fdata[:token_credential_uri]\n\n # Associated token info\n @access_token = fdata[:access_token] || fdata[\"access_token\"]\n @refresh_token = fdata[:refresh_token] || fdata[\"refresh_token\"]\n @id_token = fdata[:id_token] || fdata[\"id_token\"]\n @expires_in = fdata[:expires_in] || fdata[\"expires_in\"]\n @expires_at = fdata[:expires_at] || fdata[\"expires_at\"]\n @issued_at = fdata[:issued_at] || fdata[\"issued_at\"]\n end",
"def initialize(options={})\n @next_url = options[:callback_url] \n @sess = true\n @secure = SECURE_AUTHSUB_ENABLED # set secure = true for signed AuthSub requests\n if options[:auth_token]\n @client.authsub_token = options[:auth_token] \n # Set private key when upgrading token to session\n @client.authsub_private_key = private_key if @secure\n end\n end",
"def initialize access_key_id, secret_access_key, opts={}\n opts = DEFAULTS.merge opts\n @sts = SecurityTokenService.new access_key_id, secret_access_key\n @endpoint = opts[:endpoint]\n @debug = opts[:debug]\n end",
"def get_access_token(options={})\n response=consumer.token_request(consumer.http_method,(consumer.access_token_url? ? consumer.access_token_url : consumer.access_token_path),self,options)\n OAuth::AccessToken.new(consumer,response[:oauth_token],response[:oauth_token_secret])\n end",
"def initialize(options)\n required_arguments = %i(client_id client_secret refresh_token)\n raise ArgumentError if required_arguments & options.keys != required_arguments\n\n @client_id = options[:client_id]\n @client_secret = options[:client_secret]\n @access_token = options[:access_token]\n @refresh_token = options[:refresh_token]\n end",
"def client_options\n\topts = {}\n\topts['client_id'] = 'OAuth Client ID'\n\topts['service_email'] = 'Service E-Mail'\n\topts['key'] = \"/path/toprivatekey.p12\"\n\topts['project_id'] = 'Project ID'\n\topts\nend",
"def initialize(options = {})\n @aliyun_access_id = options[:access_id]\n @aliyun_access_key = options[:access_key]\n @aliyun_bucket = options[:bucket]\n @aliyun_protocol_relative_url = !!options[:protocol_relative_url]\n @aliyun_protocol = options[:protocol] || 'http'\n\n @aliyun_upload_host = \"#{@aliyun_bucket}.#{get_endpoint(options)}\"\n @aliyun_internal_host = \"#{@aliyun_bucket}.#{get_endpoint(options.merge(internal: true))}\"\n @aliyun_external_host = \"#{@aliyun_bucket}.#{get_endpoint(options.merge(internal: false))}\"\n @aliyun_alias_host = options[:host_alias] || @aliyun_upload_host\n end",
"def oauth_client(options = {})\n @@linkedin_config ||= LinkedinBackup.load_config\n \n @key = @@linkedin_config['consumer_key']\n @secret = @@linkedin_config['consumer_secret']\n \n @client = Linkedin2::Consumer.new(@key, @secret,options )\n end",
"def initialize(options)\n super(options)\n @atmos_options = {\n :url => @options[:url],\n :uid => @options[:uid],\n :secret => @options[:secret]\n }\n @tag = @options[:tag]\n @http_client = HTTPClient.new\n # TODO: Remove this line once we get the proper certificate for atmos\n @http_client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE\n end",
"def authorize(options = {})\r\n # full_res_file_access = ['10.128.99.55','10.128.1.167','10.224.6.10','10.128.99.167','10.128.98.50','10.224.6.26','10.224.6.35','172.16.1.94', '66.234.38.35']\r\n #'65.88.88.115'\r\n # logger = Java::edu.illinois.library.cantaloupe.script.Logger\r\n # logger.debug(\"CONTEXT HASH: #{context}\")\r\n # logger.debug(\"REQUEST URI: #{context['request_uri']}\")\r\n if context['request_uri'].include?(\"info.json\") \r\n true\r\n else \r\n type = is_region?()? \"full_res\" : derivative_type(context['resulting_size'])\r\n # logger.debug(\"TYPE: #{type}\")\r\n rights = get_rights(context['identifier'], context['client_ip'])\r\n allowed = returns_rights?(rights) && is_not_restricted?(rights, type)\r\n # logger.debug(\"ALLOWED? #{allowed}\")\r\n allowed\r\n end\r\n end",
"def profiles_post(options = {})\n\n=begin\n #add access token if it exists\n url = \"\"\n if options[:access_token]\n url = \"https://api.meetup.com/2/profile.json?access_token=#{options[:access_token]}\"\n #url = \"https://api.meetup.com/2/profile.json\"\n else\n url = \"https://api.meetup.com/2/profile.json\"\n end\n=end\n\n url = \"https://api.meetup.com/2/profile.json\"\n\n puts \"profiles post url #{url}\"\n\n response = post_response(url,options)\n\n if response == \"OK\"\n puts \"OK\"\n else\n puts response.to_yaml\n end\n end",
"def options\n # figure out our options for this request\n add_ssl_options(\n # for GETs, we pass the params to Faraday to encode\n {params: get_args}.merge(HTTPService.http_options).merge(raw_options)\n )\n end",
"def normalize_options(options)\n options.merge!(\n :format => @format,\n :api_key => @api_key,\n :expire => Time.now.to_i + 600 # Grant this request 10 minutes\n ).merge!(:sig => Utils.generate_signature(options, @api_secret))\n end",
"def apply_api_key(options)\n options.merge! :query => {} unless options.has_key? :query\n options[:query].merge!({ :key => Google.configuration.api_key })\n end",
"def options\n {\n :headers => {\n :accept => 'application/json',\n :accept_encoding => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',\n :user_agent => \"Zendesk API #{Zendesk::VERSION}\"\n },\n :url => @url\n }.merge(client_options)\n end",
"def initialize options\n require 'json'\n require 'net/http'\n require 'uri'\n\n super\n\n url = URI options['keystone_url']\n url += '/v2.0/tokens'\n\n @keystone_login = keystone_login_request_body options\n @keystone_path = url.path\n @http = http url\n\n @connect_time = nil\n @login_time = nil\n @total_time = nil\n end",
"def init(options={})\n self.application_token = options[:application_token] if options[:application_token].present?\n intialize_digital_ocean_api_connection\n end",
"def initialize(options = {})\n client_id = options[:client_id]\n\n @oauth2_client = TwitchOAuth2::Client.new(\n client_id: client_id, **options.slice(:client_secret, :redirect_uri, :scopes)\n )\n\n @token_type = options.fetch(:token_type, :application)\n\n @tokens = @oauth2_client.check_tokens(\n **options.slice(:access_token, :refresh_token), token_type: @token_type\n )\n\n CONNECTION.headers['Client-ID'] = client_id\n\n renew_authorization_header if access_token\n end",
"def initialize(client_id, private_key, options = {})\n @client_id = client_id\n @url_signer = UrlSigner.new(private_key)\n @connect_timeout = options[:connect_timeout] || DEFAULT_CONNECT_TIMEOUT\n @read_timeout = options[:read_timeout] || DEFAULT_READ_TIMEOUT\n @retry_timeout = options[:retry_timeout] || DEFAULT_RETRY_TIMEOUT\n @http_client = Carto::Http::Client.get(HTTP_CLIENT_TAG)\n end",
"def initialize(options = {})\n opts = {\n oauth_site: 'https://user.gini.net/',\n oauth_redirect: 'http://localhost',\n api_uri: 'https://api.gini.net',\n api_version: 'v1',\n api_type: 'json',\n upload_timeout: 90,\n processing_timeout: 180,\n log: Logger.new(STDOUT),\n user_agent: \"gini-api-ruby/#{VERSION} (Faraday v#{Faraday::VERSION})\"\n }.merge(options)\n\n # Ensure mandatory keys are set\n [:client_id, :client_secret].each do |k|\n raise Gini::Api::Error.new(\"Mandatory option key is missing: #{k}\") unless opts.key?(k)\n end\n\n # Populate instance variables from merged opts\n opts.each do |k, v|\n instance_variable_set(\"@#{k}\", v)\n self.class.send(:attr_reader, k)\n end\n\n # Ensure STDOUT is flushed\n STDOUT.sync = true\n\n # Sanitize api_uri\n @api_uri.sub!(/(\\/)+$/, '')\n\n # Register parser (json+xml) based on API version\n register_parser\n\n @log.info('Gini API client initialized')\n @log.info(\"Target: #{@api_uri}\")\n end",
"def client(options = {})\n pgt = options.delete(:pgt)\n url = options[:url]\n raise 'URL not given' unless url\n raise 'PGT not given' unless pgt\n\n options.update(:headers => {\n 'X-Client-ID' => CLIENT_ID\n })\n\n Faraday.new(options) do |f|\n f.request :cas_proxy_auth, pgt, url\n f.response :json, :content_type => %r{\\bjson\\Z}\n f.adapter :net_http\n end\n end",
"def http_options; end",
"def initialize(options={})\n @debug = options[:debug]\n @wskey = options[:wskey]\n @secret = options[:secret]\n @principalDNS = options[:principalDNS]\n @principalID = options[:principalID]\n end",
"def initialize(url, options = {})\n # sets the URL to be shortened\n self.url = url\n # allows an instance-level override for the api key\n @api_key = options[:api_key]\n # allows an instance-level override for the timeout\n @timeout = options[:timeout]\n # allows an instance-level override for the proxy\n @proxy = URI(options[:proxy]) if options[:proxy]\n end",
"def http_options\n {\n followlocation: true,\n ssl_verifypeer: false,\n ssl_verifyhost: 0\n }\n end",
"def base_opts\n {\n client_id: '277ef29692f9a70d511415dc60592daf4cf2c6f6552d3e1b769924b2f2e2e6fe',\n client_secret: 'd6106f26e8ff5b749a606a1fba557f44eb3dca8f48596847770beb9b643ea352'\n }\n end",
"def initialize(ctoken, csecret, options={})\n @ctoken, @csecret, @consumer_options = ctoken, csecret, {}\n @api_endpoint = options[:api_endpoint] || 'http://api.teambox.com'\n @signing_endpoint = options[:signing_endpoint] || 'http://api.teambox.com'\n if options[:sign_in]\n @consumer_options[:authorize_path] = '/oauth/authenticate'\n end\n end",
"def initialize(http_options = {})\n @http_options = http_options\n end",
"def initialize(options = {})\n\n @conn = Faraday.new do |f|\n f.use Middleware, self\n f.response :logger\n f.request :multipart\n f.request :url_encoded\n f.adapter Faraday.default_adapter\n end\n @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)\n [:username, :password, :client_id, :client_secret, :auth_code, :access_token, :refresh_token, :ttl, :rest_url, :rest_token, :auth_host, :rest_host].each do |opt|\n self.send \"#{opt}=\", options[opt] if options[opt]\n end\n\n end",
"def initialize(client_id, client_secret, opts={})\n @id = client_id\n @secret = client_secret\n @site = opts.delete(:site)\n ssl = opts.delete(:ssl)\n @options = { :authorize_url => '/oauth/authorize',\n :access_token_url => '/oauth/access_token', \n :access_token_method => :post,\n :connection_opts => {},\n :parse_json => false,\n :raise_errors => true }.merge(opts)\n @options[:connection_opts][:ssl] = ssl if ssl\n end",
"def setup(options={})\n get_application_keys unless has_application_keys?\n\n if options[:client_id]\n Datapimp.config.set \"google_client_id\", options[:client_id]\n end\n\n if options[:client_secret]\n Datapimp.config.set \"google_client_secret\", options[:client_secret]\n end\n\n if has_refresh_token?\n refresh_access_token!\n elsif respond_to?(:ask)\n Launchy.open(browser_authorization_url)\n say(\"\\n1. Open this page:\\n%s\\n\\n\" % auth_client.authorization_uri)\n consume_auth_client_code ask(\"2. Enter the authorization code shown in the page: \", String)\n end\n end",
"def initialize\n @settings = Settings.instance\n @options = {\n base_uri: @settings.get('api_endpoint'),\n timeout: @settings.get('timeout').to_i / 1000\n }\n end",
"def initialize(options = {})\n raise ArgumentError, \"Options hash required.\" unless options.is_a?(Hash)\n\n @dev_id = options[:dev_id]\n @secret_key = options[:secret_key]\n end",
"def initialize(options = {})\n LinkedInConnect.load_config.each do |k, v|\n instance_variable_set(\"@#{k}\", v)\n end\n @consumer_options = {\n :site => @site,\n :request_token_path => @request_token_path,\n :authorize_path => @authorize_path,\n :access_token_path => @access_token_path,\n :oauth_callback => @oauth_callback\n }\n end",
"def oauth_access_token(client_id, client_secret, options={})\n url = self.format_url('/oauth/access_token', {\n :client_id => client_id,\n :client_secret => client_secret\n }.merge(options || {}))\n \n response = self.perform_get(url)\n response_hash = {}\n response.split('&').each do |value|\n value_pair = value.split('=')\n response_hash[value_pair[0]] = value_pair[1]\n end\n response_hash\n end",
"def initialize(auth_options)\n\t\t\t\t@options = OkAuth.getUrlOptions\n\t\t\t\t@options = @options.merge(auth_options)\n\t\t\tend",
"def options\n Http::Options.new(self, @options).invoke\n end",
"def set_config(options)\n return @api.do_request(\"POST\", get_base_api_path() + \"/config\", options)\n end",
"def get_access_key\n return \"AIzaSyBUKwL2ClTAaKwn1csWuOOhNgKj5kv3QeA\"\nend",
"def initialize(options= {})\n @login = options[:login] || ENV['VZAAR_LOGIN'] || ''\n application_token = options[:application_token] || ENV['VZAAR_APPLICATION_TOKEN'] || ''\n server = options[:server] || ENV['VZAAR_SERVER'] || VZAAR_LIVE_SERVER\n @logger = options[:logger] || Logger.new(STDOUT)\n\n server.gsub! 'http://', ''\n server.gsub! 'https://', ''\n consumer = OAuth::Consumer.new '', '', { :site => \"http://#{server}\" }\n @public_connection = OAuth::AccessToken.new consumer, '', ''\n consumer = OAuth::Consumer.new '', '', { :site => \"https://#{server}\" }\n if @login.length > 0 and application_token.length > 0\n @auth_connection = OAuth::AccessToken.new consumer, @login, application_token\n else\n # Authenticated requests won't be possible\n @auth_connection = nil\n log_info \"Authenticated calls won't be possible\"\n end\n end",
"def initialize options = {}\n @api_token = options[:api_token]\n end",
"def post url, options={}\n response = self.class.post(url, {:body => options}).parsed_response\n raise Skydrive::Error.new(response[\"error\"]) if response[\"error\"]\n response[\"data\"] ? response[\"data\"] : response\n end",
"def configure_youtube(access_token, refresh_token)#, expiresat)\n Yt.configure do |config|\n config.client_id = ENV[\"google_client_id\"]\n config.client_secret = ENV[\"google_client_secret\"]\n end\n client = Yt::Account.new(access_token: access_token, refresh_token: refresh_token)\n client\n end",
"def fetch_refresh_token(options)\n password_options = {\n :brightbox_password => options[:password],\n :brightbox_support_two_factor => true,\n :brightbox_one_time_password => options[:one_time_password]\n }\n\n default_fog_options = password_auth_params.merge(password_options)\n connection = Fog::Compute.new(default_fog_options)\n begin\n connection.get_access_token!\n rescue Excon::Errors::Unauthorized\n raise Brightbox::Api::ApiError, \"Invalid credentials\"\n end\n connection\n end",
"def initialize(options={})\n @access_token = options[:access_token]\n @connection = Faraday.new(url: Behance::Client::API_URL) do |b|\n b.adapter Faraday.default_adapter\n b.use FaradayMiddleware::ParseJson\n end\n end",
"def refresh! options = {}\n fetch_access_token! options\n end",
"def connect(options={})\n query = query_string(options)\n request = generate_request(query)\n begin\n response = Net::HTTP.get_response(request)\n Response.new response\n rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, SocketError,\n Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e\n puts \"Failed to connect: #{e}\"\n end\n end",
"def options(url, options = {}, &block)\n request HttpOptions, url, options, &block\n end",
"def options\n {\n headers: {\n 'Content-Type': 'application/json;charset=UTF-8',\n 'Authorization': 'Handle sessionId=\"' + @session_id + '\"'\n },\n verify: false\n }\n end",
"def initialize(options = {})\n options = { :access_token => options } if options.is_a? String\n options = self.class.options.merge(options)\n\n # Parse `api_url` option\n if url = options.delete(:api_url)\n uri = URI.parse(url)\n options[:api_scheme] = uri.scheme\n options[:api_host] = uri.host + (uri.port != 80 && uri.port != 443 ? \":#{uri.port}\" : '')\n end\n\n @access_token = options[:access_token] if options[:access_token]\n @api_scheme = options[:api_scheme]\n @api_host = options[:api_host]\n @api_version = options[:api_version]\n @api_prefix = options[:api_prefix]\n @client_token = options[:client_token] if options[:client_token]\n @transport = options[:transport]\n @result_format = options[:result_format]\n\n # Include transport\n transport_module = Lapse::Transport::TRANSPORT_MAP[@transport]\n raise 'Invalid transport' unless transport_module\n self.extend transport_module\n end",
"def initialize(access_hash = nil)\n @access_token = access_hash[\"access_token\"] if access_hash\n # binding.pry\n end",
"def update! options = {}\n # Normalize all keys to symbols to allow indifferent access.\n options = deep_hash_normalize options\n\n self.authorization_uri = options[:authorization_uri] if options.key? :authorization_uri\n self.token_credential_uri = options[:token_credential_uri] if options.key? :token_credential_uri\n self.client_id = options[:client_id] if options.key? :client_id\n self.client_secret = options[:client_secret] if options.key? :client_secret\n self.scope = options[:scope] if options.key? :scope\n self.target_audience = options[:target_audience] if options.key? :target_audience\n self.state = options[:state] if options.key? :state\n self.code = options[:code] if options.key? :code\n self.redirect_uri = options[:redirect_uri] if options.key? :redirect_uri\n self.username = options[:username] if options.key? :username\n self.password = options[:password] if options.key? :password\n self.issuer = options[:issuer] if options.key? :issuer\n self.person = options[:person] if options.key? :person\n self.sub = options[:sub] if options.key? :sub\n self.expiry = options[:expiry] || 60\n self.audience = options[:audience] if options.key? :audience\n self.signing_key = options[:signing_key] if options.key? :signing_key\n self.extension_parameters = options[:extension_parameters] || {}\n self.additional_parameters = options[:additional_parameters] || {}\n self.access_type = options.fetch(:access_type) { :offline }\n update_token! options\n self\n end",
"def api(method, url, options = {})\n unless [:get, :delete, :post, :put, :patch].include? method\n raise \"Unknown REST method: #{method}\"\n end\n \n config = RequestConfig.new\n config.authorization_bearer = @authorization_bearer\n config.method = method\n config.access_token = options[:access_token]\n config.request_params = options[:request_params]\n config.request_body = options[:request_body]\n config.content_type = \"application/json\" unless url == @refresh_token_url\n config.form_encoding = true if url == @refresh_token_url\n refresh_token = options[:refresh_token]\n user_uid = options[:user_uid]\n\n puts \"*\" * 88\n puts url.to_s\n puts method.to_s\n configp = config.dup\n puts configp.finalize!.to_hash.inspect\n puts \"*\" * 88\n \n request = Typhoeus::Request.new url, config.finalize!\n request.on_complete do |response|\n case\n when response.success?\n puts \"Success\"\n @callback_request_made.call\n return Echidna::Response.new response\n when response.timed_out?\n puts \"Timed out. Is google down?\"\n return Echidna::Error.new response\n when response.code == 401\n puts \"In refresh block\"\n if refresh_token && @client_id && @client_secret\n new_access_token = fetch_new_access_token(user_uid, refresh_token)\n options.delete(:refresh_token)\n options[:access_token] = new_access_token\n return api(method, url, options)\n else\n return Echidna::Error.new response\n end\n when response.code == 0\n puts\"Could not get an http response, something's wrong.\"\n return Echidna::Error.new response\n else\n puts \"HTTP request failed: #{response.code}\"\n return Echidna::Error.new response\n end\n end\n \n @hydra.queue(request)\n @hydra.run\n \n request\n end",
"def initialize(options)\n @settings = options\n\n check_settings(:aws_access_key_id, :aws_default_region,\n :aws_secret_access_key)\n end",
"def initialize(options = {:retry_auth => true}) \n @authuser = options[:username] || (raise Exception::MissingArgument, \"Must supply a :username\")\n @authkey = options[:api_key] || (raise Exception::MissingArgument, \"Must supply an :api_key\")\n @auth_url = options[:auth_url] || @auth_url = CloudServers::AUTH_USA\n\n auth_uri=nil\n begin\n auth_uri=URI.parse(@auth_url)\n rescue Exception => e\n raise Exception::InvalidArgument, \"Invalid :auth_url parameter: #{e.message}\"\n end\n raise Exception::InvalidArgument, \"Invalid :auth_url parameter.\" if auth_uri.nil? or auth_uri.host.nil?\n @auth_host = auth_uri.host\n @auth_port = auth_uri.port\n @auth_scheme = auth_uri.scheme\n\n @retry_auth = options[:retry_auth]\n @proxy_host = options[:proxy_host]\n @proxy_port = options[:proxy_port]\n @authok = false\n @http = {}\n CloudServers::Authentication.new( self )\n self.class.last_connection = self\n end",
"def client_options\n {\n client_id: Rails.application.secrets.google_client_id,\n client_secret: Rails.application.secrets.google_client_secret,\n authorization_uri: 'https://accounts.google.com/o/oauth2/auth',\n token_credential_uri: 'https://accounts.google.com/o/oauth2/token',\n scope: Google::Apis::CalendarV3::AUTH_CALENDAR,\n redirect_uri: callback_url\n }\n end",
"def authenticate\n Access.new(\n 'access_token' => access_token,\n 'token_type' => token_type,\n 'expires_in' => 1 << (1.size * 8 - 2) - 1 # Max int value\n )\n end",
"def initialize(options = {})\n # Mandatory params\n @client_id = @@client_id || options.fetch(:client_id)\n @client_key = @@client_key || options.fetch(:client_key)\n @tenant_id = @@tenant_id || options.fetch(:tenant_id)\n\n # Optional params\n @subscription_id = @@subscription_id || options[:subscription_id]\n @resource_group = @@resource_group || options[:resource_group]\n @api_version = @@api_version || options[:api_version] || '2015-01-01'\n @grant_type = @@grant_type || options[:grant_type] || 'client_credentials'\n\n # The content-type used for all internal http requests\n @content_type = @@content_type || 'application/json'\n\n # Call the get_token method to set this.\n @token = @@token || options[:token]\n\n # Base URL used for REST calls. Modify within method calls as needed.\n @base_url = Azure::Armrest::RESOURCE\n end",
"def initialize(options={})\n @api_key = options[:api_key] || config.api_key\n @path = options[:path]\n @params = options[:params]\n @http_request_options = options[:http_request_options] || {}\n end",
"def initialize(options)\n self.api_key, self.secret_key = options[\"api_key\"], options[\"secret_key\"]\n self.district_number = options[\"district_number\"]\n self.endpoint = options[\"endpoint\"] || TIES::ENDPOINT\n end",
"def azure_options\n options = { tenant_id: tenant_id!,\n subscription_id: subscription_id,\n credentials: ::MsRest::TokenCredentials.new(token_provider),\n active_directory_settings: ad_settings,\n base_url: endpoint_settings.resource_manager_endpoint_url }\n options[:client_id] = client_id if client_id\n options[:client_secret] = client_secret if client_secret\n options\n end",
"def azure_options\n options = { tenant_id: tenant_id!,\n subscription_id: subscription_id,\n credentials: ::MsRest2::TokenCredentials.new(token_provider),\n active_directory_settings: ad_settings,\n base_url: endpoint_settings.resource_manager_endpoint_url }\n options[:client_id] = client_id if client_id\n options[:client_secret] = client_secret if client_secret\n options\n end",
"def access_token_connection\n Faraday.new(access_token_url) do |conn|\n conn.use :breakers\n conn.response :json, content_type: /\\bjson$/\n conn.adapter Faraday.default_adapter\n end\n end",
"def http_client(options)\n Net::HTTP.new(endpoint.host, endpoint.port).tap do |http|\n if endpoint.instance_of?(URI::HTTPS)\n cert = self.class.fingerprint_cert(endpoint.host)\n http.use_ssl = true\n http.verify_callback = ->(ok, store) { verify_fingerprint(cert.serial, ok, store) } if cert\n options[:ssl].call(http) if options[:ssl].respond_to?(:call)\n end\n end\n end",
"def options_for_klient(options = {})\n {\n # TODO Kaui doesn't support multi-tenancy yet\n :api_key => KillBillClient.api_key,\n :api_secret => KillBillClient.api_secret,\n :username => current_user.kb_username || KillBillClient.username,\n :password => current_user.password || KillBillClient.password,\n :session_id => current_user.kb_session_id\n }.merge(options)\n end",
"def initialize(options = {})\n requires!(options, :login, :password)\n super\n\n config = lambda do |config|\n config.login = options[:login]\n config.password = options[:password]\n config.api_version = options[:api_version] || \"3.6\"\n config.endpoint = test? ? self.test_url : self.live_url\n config.namespace = \"http://soap.vindicia.com\"\n end\n\n if Vindicia.config.is_configured?\n config.call(Vindicia.config)\n else\n Vindicia.configure(&config)\n end\n\n requires!(options, :account_id)\n @account_id = options[:account_id]\n\n @transaction_prefix = options[:transaction_prefix] || \"X\"\n\n @min_chargeback_probability = options[:min_chargeback_probability] || 65\n @cvn_success = options[:cvn_success] || %w{M P}\n @avs_success = options[:avs_success] || %w{X Y A W Z}\n\n @allowed_authorization_statuses = %w{Authorized}\n end",
"def get_secrets_with_http_info(opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: SecretStoreItemApi.get_secrets ...'\n end\n # unbox the parameters from the hash\n store_id = opts[:'store_id']\n # verify the required parameter 'store_id' is set\n if @api_client.config.client_side_validation && store_id.nil?\n fail ArgumentError, \"Missing the required parameter 'store_id' when calling SecretStoreItemApi.get_secrets\"\n end\n # resource path\n local_var_path = '/resources/stores/secret/{store_id}/secrets'.sub('{' + 'store_id' + '}', CGI.escape(store_id.to_s))\n\n # query parameters\n query_params = opts[:query_params] || {}\n query_params[:'cursor'] = opts[:'cursor'] if !opts[:'cursor'].nil?\n query_params[:'limit'] = opts[:'limit'] if !opts[:'limit'].nil?\n\n # header parameters\n header_params = opts[:header_params] || {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n\n # form parameters\n form_params = opts[:form_params] || {}\n\n # http body (model)\n post_body = opts[:debug_body]\n\n # return_type\n return_type = opts[:debug_return_type] || 'InlineResponse2006'\n\n # auth_names\n auth_names = opts[:debug_auth_names] || ['token']\n\n new_options = opts.merge(\n :operation => :\"SecretStoreItemApi.get_secrets\",\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => return_type\n )\n\n data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: SecretStoreItemApi#get_secrets\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def connect options={}\n\n Thread.current[\"GopDataTrust/Api/@token\"] = (options[:token] || self.default_token)\n if options[:production].eql?(true) || (options[:production].nil? && self.default_production?)\n Thread.current[\"GopDataTrust/Api/@base_url\"] = \"https://www.gopdatatrust.com/v2/api/\"\n else\n Thread.current[\"GopDataTrust/Api/@base_url\"] = \"https://lincoln.gopdatatrust.com/v2/api/\"\n end\n\n\n nil\n end",
"def exec(options)\n self.params = options[:params]\n self.request = options[:request]\n self.caller = options[:caller]\n self.options = options.except(:params, :request, :caller)\n\n setup\n raise Lev.configuration.security_transgression_error, auth_error_details unless authorized?\n validate_paramified_params\n handle unless errors?\n end",
"def sign_request(options, authorize = true)\n options.merge!(:auth_token => self.auth.token(false).to_s, :api_key => @api_key) if authorize and self.auth.token(false)\n options.delete(:api_sig)\n options.merge!(:api_sig => Digest::MD5.hexdigest(@api_secret + options.to_a.sort_by{|k| k[0].to_s}.flatten.join)) if @api_secret\n end",
"def initialize(options)\n if options[:auth]\n @auth = options[:auth]\n @auth_type = options[:auth_type] || :client_login\n else\n request_auth(options[:email],options[:password])\n end\n @cache = GoogleReaderApi::Cache.new(2)\n end",
"def access_token_connection\n Faraday.new(access_token_url, headers: headers) do |conn|\n conn.use :breakers\n conn.response :json, content_type: /\\bjson$/\n conn.adapter Faraday.default_adapter\n end\n end",
"def get url, options={}\n response = self.class.get(url, {:query => options}).parsed_response\n raise Skydrive::Error.new(response[\"error\"]) if response[\"error\"]\n response[\"data\"] ? response[\"data\"] : response\n end",
"def update(options = {})\n data = PostData.new\n data[:user] = @login\n data[:pass] = @password\n if options[:tid]\n data[:tid] = options[:tid]\n else\n data[:ord_id] = options[:ord_id]\n data[:service_id] = options[:service_id]\n end\n\n ssl_post(STATUS_TEST_URL, data.to_post_data)\n end",
"def get_access_token(code, _options = {})\n conn = Faraday.new(url: base_url) do |faraday|\n faraday.request :url_encoded\n faraday.adapter Faraday.default_adapter\n end\n params = access_token_params(code)\n conn.post do |req|\n req.url \"/api/oauth2/token\"\n req.body = params\n req.headers[\"Accept\"] = \"application/json\"\n end\n end",
"def initialize( aws_access_key_id, aws_secret_access_key, options = {} )\n @aws_access_key_id, @aws_secret_access_key = aws_access_key_id, aws_secret_access_key\n opts = DEFAULT_SQS_OPTIONS.merge(options)\n @endpoint = opts[:endpoint]\n end",
"def config(api_id, api_key, options={})\n @api_id = api_id\n @api_key = api_key\n @api_endpoint = URI.parse(options.delete(:url))\n @api_options = options\n end",
"def config(api_id, api_key, options={})\n @api_id = api_id\n @api_key = api_key\n @api_endpoint = URI.parse(options.delete(:url))\n @api_options = options\n end",
"def set_access_token(token, options={})\n options[:access_token] = token\n options[:mode] = :query\n options[:param_name] = \"oauth2_access_token\"\n @access_token = OAuth2::AccessToken.from_hash oauth2_client, options\n end",
"def get_access_code\n data = {\n :client_id => @a_conf[:client_id],\n :client_secret => @a_conf[:client_secret],\n :code => @conf[:oauth][:device_code],\n :grant_type => 'http://oauth.net/grant_type/device/1.0',\n }\n #puts \"Data for get_access_code\"\n #pp data\n\n keep_trying = true \n\n while keep_trying\n sleep ( @conf[:oauth][:verification_interval] + 1 )\n keep_trying = false if (Time.now - @conf[:oauth][:verification_interval_start]) > @conf[:oauth][:verification_expires_in] \n if keep_trying\n json = RestClient.post \"https://accounts.google.com/o/oauth2/token\", data\n response = JSON.parse(json)\n\n if response[\"error\"]\n if response[\"error\"] == \"authorization_pending\"\n puts \"Still waiting for user authorization\"\n elsif response[\"error\"] == \"slow_down\"\n puts \"requesting too fast!\"\n else\n puts \"Unknow error response : '#{response[\"error\"]}'\"\n end\n elsif response[\"access_token\"]\n #puts \"got #{response[\"access_token\"]}\"\n @conf[:oauth][:refresh_token] = response[\"refresh_token\"]\n @conf[:oauth][:token_type] = response[\"token_type\"]\n @conf[:oauth][:access_token] = response[\"access_token\"]\n @conf[:oauth][:expires_in] = response[\"expires_in\"]\n keep_trying = false\n return true\n else\n # No Token\n end\n else\n puts \"Verification interval expired and no access token received\"\n @conf[:oauth] = Hash.new\n end\n end\n rescue RestClient::BadRequest => e\n puts \"Bad request for 'get_access_code'\"\n puts e.message\n #puts e.backtrace\n rescue => e\n puts \"Something else bad happened during 'get_access_code'\" \n puts e.message\n #puts e.backtrace\n end",
"def initialize(options = {})\n @services = { }\n\n settings = Config.client_settings(options)\n\n # pick up the username from the options, the global, or assume no username\n @username = settings[:username]\n\n # do a similar thing for the api key\n @api_key = settings[:api_key]\n\n # grab token pair\n @userId = settings[:userId]\n @authToken = settings[:authToken]\n\n # and the endpoint url\n @endpoint_url = settings[:endpoint_url] || API_PUBLIC_ENDPOINT\n\n # set the user agent to the one provided, or set it to a default one\n @user_agent = settings[:user_agent] || \"softlayer_api gem/#{SoftLayer::VERSION} (Ruby #{RUBY_PLATFORM}/#{RUBY_VERSION})\"\n\n # and assign a time out if the settings offer one\n @network_timeout = settings[:timeout] if settings.has_key?(:timeout)\n\n raise \"A SoftLayer Client requires an endpoint URL\" if !@endpoint_url || @endpoint_url.empty?\n end",
"def client_options\n {\n client_id: Rails.application.secrets.google_client_id,\n client_secret: Rails.application.secrets.google_client_secret,\n authorization_uri: 'https://accounts.google.com/o/oauth2/auth',\n token_credential_uri: 'https://accounts.google.com/o/oauth2/token',\n scope: Google::Apis::CalendarV3::AUTH_CALENDAR,\n redirect_uri: callback_url\n }\n end",
"def fetch\n Net::HTTP.start(url.host, url.port, use_ssl: true) do |http|\n req = Net::HTTP::Post.new(url)\n req[\"Accept\"] = \"application/json\"\n data = {\n \"client_id\" => client_id,\n \"client_secret\" => client_secret,\n \"grant_type\" => \"client_credentials\",\n \"scope\" => \"/read-public\"\n }\n req.set_form_data(data)\n body = http.request(req).body\n JSON.parse(body)[\"access_token\"]\n end\n end",
"def initialize(options = {})\n\t\t# set some sensible defaults\n\t\t@url = 'https://secure.authorize.net/gateway/transact.dll'\n\t\t@delim_data = 'TRUE'\n\t\t@relay_response = 'FALSE'\n\t\t@version = API_VERSION\n\t\t\n\t\t# include all provided data\n\t\tsuper options\n\tend",
"def retrieve(options = {})\n body = options.fetch(:body, {})\n\n @client.post(\"oauth/token?grant_type=client_credentials\", body, options)\n end",
"def init_http_client(options)\n http = Net::HTTP.new(@base_uri.host, 443)\n http.use_ssl = true if @base_uri.scheme == \"https\"\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE # FIXME: not 100% supported\n self.http_client = http\n end",
"def initialize(access_key, secret_key)\n @access_key = access_key\n @secret_key = secret_key\n end"
] |
[
"0.72505903",
"0.6038918",
"0.583578",
"0.57985514",
"0.5779334",
"0.5758519",
"0.5720048",
"0.5704394",
"0.5670463",
"0.564725",
"0.56459254",
"0.56380093",
"0.5605419",
"0.5554778",
"0.55327874",
"0.5530953",
"0.552661",
"0.5480762",
"0.54777825",
"0.54507196",
"0.54481685",
"0.5349427",
"0.53441215",
"0.5333955",
"0.5314121",
"0.53080964",
"0.53054297",
"0.5296944",
"0.52841234",
"0.5277449",
"0.52731407",
"0.5269868",
"0.52451146",
"0.5237804",
"0.52273107",
"0.5208689",
"0.52082336",
"0.5191239",
"0.51878965",
"0.51871955",
"0.5156648",
"0.5153161",
"0.5152908",
"0.51463914",
"0.5140067",
"0.51399976",
"0.5136838",
"0.51172775",
"0.5112254",
"0.51044947",
"0.5098153",
"0.50708246",
"0.50487185",
"0.5048288",
"0.5042178",
"0.5038551",
"0.50360686",
"0.50330716",
"0.50264496",
"0.50149167",
"0.5014605",
"0.5008784",
"0.500612",
"0.50039375",
"0.49970093",
"0.49961886",
"0.49902162",
"0.49866343",
"0.49830726",
"0.49721345",
"0.4969103",
"0.4966626",
"0.49601886",
"0.4959833",
"0.49438107",
"0.4943495",
"0.49423227",
"0.49421754",
"0.49416378",
"0.4936331",
"0.49345654",
"0.493417",
"0.49315035",
"0.49307203",
"0.49247316",
"0.4923674",
"0.49235094",
"0.491701",
"0.49155903",
"0.49141058",
"0.49141058",
"0.4903096",
"0.4902682",
"0.49022412",
"0.49017912",
"0.4894827",
"0.48928633",
"0.48901168",
"0.4886264",
"0.48830503"
] |
0.7309609
|
0
|
Use callbacks to share common setup or constraints between actions.
|
def set_dimension
@dimension = Dimension.find(params[:id])
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def setup_handler\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def workflow\n end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup\n # override and do something appropriate\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def before_action \n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def setup_signals; end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def initialize(*args)\n super\n @action = :set\nend",
"def after_set_callback; end",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def around_hooks; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def duas1(action)\n action.call\n action.call\nend",
"def shared_action(name, &block)\n @controller.shared_actions[name] = block\n end",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] |
[
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576",
"0.53124547",
"0.529654",
"0.5296262",
"0.52952296",
"0.52600986",
"0.52442724",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.5232394",
"0.523231",
"0.5227454",
"0.52226824",
"0.52201617",
"0.5212327",
"0.52079266",
"0.52050185",
"0.51754695",
"0.51726824",
"0.51710224",
"0.5166172",
"0.5159343",
"0.51578903",
"0.51522785",
"0.5152022",
"0.51518047",
"0.51456624",
"0.51398855",
"0.5133759",
"0.5112076",
"0.5111866",
"0.5111866",
"0.5110294",
"0.5106169",
"0.509231",
"0.50873137",
"0.5081088",
"0.508059",
"0.50677156",
"0.50562143",
"0.5050554",
"0.50474834",
"0.50474834",
"0.5036181",
"0.5026331",
"0.5022976",
"0.5015441",
"0.50121695",
"0.5000944",
"0.5000019",
"0.4996878",
"0.4989888",
"0.4989888",
"0.49864885",
"0.49797225",
"0.49785787",
"0.4976161",
"0.49683493",
"0.4965126",
"0.4958034",
"0.49559742",
"0.4954353",
"0.49535993",
"0.4952725",
"0.49467874",
"0.49423352",
"0.49325448",
"0.49282882",
"0.49269363",
"0.49269104",
"0.49252945",
"0.4923091",
"0.49194667",
"0.49174926",
"0.49173003",
"0.49171105",
"0.4915879",
"0.49155936"
] |
0.0
|
-1
|
Only allow a trusted parameter "white list" through.
|
def dimension_params
params.require(:dimension).permit(:name, :questionnaire_id)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def allowed_params\n ALLOWED_PARAMS\n end",
"def expected_permitted_parameter_names; end",
"def param_whitelist\n [:role, :title]\n end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def permitted_params\n []\n end",
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def filtered_parameters; end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def parameters_list_params\n params.require(:parameters_list).permit(:name, :description, :is_user_specific)\n end",
"def parameter_params\n params.require(:parameter).permit(:name, :description, :param_code, :param_value, :active_from, :active_to)\n end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def valid_params?; end",
"def permitted_params\n declared(params, include_missing: false)\n end",
"def permitted_params\n declared(params, include_missing: false)\n end",
"def get_params\n\t\treturn ActionController::Parameters.new(self.attributes).permit(\"account_id\", \"title\", \"category\", \"introduction\", \"tags\", \"segment_type\", \"visible\", \"status\", \"main_image\")\n\tend",
"def filter_parameters; end",
"def filter_parameters; end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def check_params; true; end",
"def valid_params_request?; end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def allowed_params\n params.require(:user).permit(:username, :email, :password, :password_confirmation)\n end",
"def list_params\n params.permit(:name)\n end",
"def check_params\n true\n end",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def additional_permitted_params\n []\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def resource_params\n params[resource_singular_name].try(:permit, self.class.param_whitelist)\n end",
"def allow_params_authentication!; end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def person_params\n # params whitelist does *not* include admin, sub, remember_token\n # TBD: share this whitelist with the list used by configuration_permitted_parameters\n # TBD: should current_password be on this list? -- for now, leaving off, since it seems to work without\n # NOTE: do not include 'admin' in this list!\n params.require(:person).permit(\n :name, \n :email, \n :description,\n :password, \n :password_confirmation\n )\n end",
"def paramunold_params\n params.require(:paramunold).permit!\n end",
"def param_params\n params.require(:param).permit(:param_category_id, :param_table_id, :name, :english_name, :weighting, :description)\n end",
"def quote_params\n params.permit!\n end",
"def list_params\n params.permit(:list_name)\n end",
"def allowed_params(parameters)\n parameters.select do |name, values|\n values.location != \"path\"\n end\n end",
"def all_params; end",
"def permitted_resource_params\n params[resource.object_name].present? ? params.require(resource.object_name).permit! : ActionController::Parameters.new\n end",
"def source_params\n params.require(:source).permit(all_allowed_params)\n end",
"def user_params\n end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def params; end",
"def get_allowed_parameters\n return _get_specific_action_config(:allowed_action_parameters, :allowed_parameters)&.map(&:to_s)\n end",
"def permitted_params\n @wfd_edit_parameters\n end",
"def user_params\r\n end",
"def param_whitelist\n whitelist = [\n :comment,\n :old_progress, :new_progress,\n :metric_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:metric_id)\n end\n \n whitelist\n end",
"def query_param\n\t\tparams.permit(:first_name, :last_name, :phone)\n\tend",
"def whitelisted_user_params\n params.require(:user).\n permit( :first_name, :last_name, :email,:password,:password_confirmation,:birthday,:gender)\n end",
"def filter_params\n\t\treturn params[:candidate].permit(:name_for_filter)\n\tend",
"def user_params\n params.permit(:id, :email, :password, :nickname, :status, :avatar, :flat_picture, :flatsharing_id, :member,\n :user, :color, :solde)\n end",
"def get_params\n\t\t\n\t\treturn ActionController::Parameters.new(self.attributes).permit(:first_name, :last_name, :email, :provider)\n\n\tend",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def valid_params(params)\n params.permit(:user_id, :photo_id, :originX, :originY, :width, :height)\n end",
"def valid_parameters\n sort_symbols(@interface.allowed_parameters)\n end",
"def params_permit\n params.permit(:id)\n end",
"def allowed_params\n params.require(:allowed).permit(:email)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def filter_params\n params.permit(*resource_filter_permitted_params)\n end",
"def community_params\n params.permit(:profile_image, :name, :description, :privacy_type, :viewed_by, {tags: []}, {features: []}, {admins: []}, :members, :location, :beacon, :creator, :ambassadors, :current_events, :past_events, :feed, :category, :address, :allow_member_post_to_feed, :allow_member_post_to_events)\n end",
"def specialty_params\n\t\tparams.require(:specialty).permit(*Specialty::DEFAULT_ACCESSIBLE_ATTRIBUTES)\n\tend",
"def authorize_params\n super.tap do |params|\n %w[display scope auth_type].each do |v|\n if request.params[v]\n params[v.to_sym] = request.params[v]\n end\n end\n end\n end",
"def feature_params_filter\n params.require(:feature).permit(:name, :cat, :lower, :upper, :opts, :category, :description, :company, :active, :unit, :icon)\n end",
"def available_activity_params\n # params.require(:available_activity).permit(:type,:geometry,:properties)\n whitelisted = ActionController::Parameters.new({\n type: params.require(:available_activity)[:type],\n geometry: params.require(:available_activity)[:geometry].try(:permit!).to_h,\n properties: params.require(:available_activity)[:properties].try(:permit!).to_h\n }).try(:permit!)\n end",
"def argument_params\n params.require(:argument).permit(:name)\n end",
"def user_params_pub\n\t \tparams[:user].permit(:hruid)\n\t end",
"def strong_params\n params.require(:success_metric).permit(param_whitelist)\n end",
"def property_params\n params.permit(:name, :is_available, :is_approved, :owner_id)\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def sponsor_params\n params.require(:sponsor).permit(WHITE_LIST)\n end",
"def whitelist_person_params\n params.require(:person).permit(:family, :pre_title, :given_name, :dates, :post_title, :epithet, :dates_of_office, same_as: [], related_authority: [], altlabel: [], note: []) # Note - arrays need to go at the end or an error occurs!\n end",
"def parameters\n nil\n end",
"def user_params \n \tparams.require(:user).permit(:name, :email, :password, :password_confirmation)# preventing CSTR\n end",
"def sequence_param_whitelist\n default_param_whitelist << \"show_index\"\n end",
"def resource_filter_permitted_params\n raise(NotImplementedError, 'resource_filter_permitted_params method not implemented')\n end",
"def normal_params\n reject{|param, val| param_definitions[param][:internal] }\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def special_device_list_params\n params.require(:special_device_list).permit(:name)\n end",
"def pull_request_params\n whitelist = [\n :url,\n :id,\n :html_url,\n :diff_url,\n :patch_url,\n :issue_url,\n :number,\n :state,\n :locked,\n :title\n ]\n params.require(:pull_request).permit(whitelist)\n end"
] |
[
"0.7121987",
"0.70541996",
"0.69483954",
"0.6902367",
"0.6733912",
"0.6717838",
"0.6687021",
"0.6676254",
"0.66612333",
"0.6555296",
"0.6527056",
"0.6456324",
"0.6450841",
"0.6450127",
"0.6447226",
"0.6434961",
"0.64121825",
"0.64121825",
"0.63913447",
"0.63804525",
"0.63804525",
"0.6373396",
"0.6360051",
"0.6355191",
"0.62856233",
"0.627813",
"0.62451434",
"0.6228103",
"0.6224965",
"0.6222941",
"0.6210244",
"0.62077755",
"0.61762565",
"0.61711127",
"0.6168448",
"0.6160164",
"0.61446255",
"0.6134175",
"0.6120522",
"0.6106709",
"0.60981655",
"0.6076113",
"0.60534036",
"0.60410434",
"0.6034582",
"0.6029977",
"0.6019861",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.6019158",
"0.60184896",
"0.60157263",
"0.6005857",
"0.6003803",
"0.60012573",
"0.59955895",
"0.5994598",
"0.5993604",
"0.5983824",
"0.5983166",
"0.5977431",
"0.597591",
"0.5968824",
"0.5965953",
"0.59647584",
"0.59647584",
"0.59566855",
"0.59506303",
"0.5950375",
"0.59485626",
"0.59440875",
"0.5930872",
"0.5930206",
"0.5925668",
"0.59235454",
"0.5917905",
"0.59164816",
"0.5913821",
"0.59128743",
"0.5906617",
"0.59053683",
"0.59052664",
"0.5901591",
"0.58987755",
"0.5897456",
"0.58970183",
"0.58942604"
] |
0.0
|
-1
|
Returns a unique, deterministically reproducible index into an array We are hashing based on strings, let's use the ascii value of each string as a starting point.
|
def index(key, size)
key.sum % size
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def find_unique(array)\n unique_id = 0\n\n array.each do |num|\n unique_id ^= num\n end\n\n unique_id\nend",
"def generateKey(string)\r\n key = {}\r\n stringIterator = 0\r\n\r\n (string.length).times do\r\n charactersIterator = string[stringIterator] - 1\r\n divisorsIterator = 0\r\n divisors = {} # Possible divisors of the array's numbers\r\n\r\n # Check which numbers are possible divisors\r\n while charactersIterator > 0\r\n\r\n if string[stringIterator] % charactersIterator == 0\r\n divisors[divisorsIterator] = charactersIterator\r\n divisorsIterator += 1\r\n end\r\n charactersIterator -= 1\r\n end\r\n key[stringIterator] = divisors[rand(divisors.length)] # Choosing random divisor to be the primary key\r\n stringIterator += 1\r\n end\r\n\r\n return key\r\nend",
"def dupe_indices(array)\n hash = Hash.new{ |k, v| k[v] = [] }\n\n array.each_with_index do |char, i|\n hash[char] << i\n end\n\n return hash.select { |k, v| v.length > 1 }\n\nend",
"def index(key, size)\n MurmurHash3::V32.str_hash(key.to_s, size) % size\n end",
"def index(key, size)\n hash_code = 0\n array_of_characters = key.split('')\n array_of_characters.each do |letter|\n hash_code += letter.ord\n end\n hash_code % size\n end",
"def test_array_hash\r\n # a = %w(brendan baird billy)\r\n # assert_equal(1047868961, a.hash)\r\n end",
"def hash_offset(array, offset)\r\n hash = {}\r\n \r\n i = 0\r\n while i < array.length \r\n if i >= (array.length - offset) #if i >= 22, in this case. So this condition applies for the last 4 elements of the array\r\n hash[array[i-array.length + offset]] = array[i] # hash[array[22-26+4]] --> hash[array[0]] --> hash[\"a\"]=array[22] --> hash[\"a\"]=\"w\"\r\n else\r\n hash[(array[i].ord + offset).chr] = array[i] #otherwise do the normal offset by 4\r\n end\r\n i += 1\r\n end\r\n return hash\r\nend",
"def find_uniq_int(array)\n\tuniq_id = 0\n\n\tarray.each do |element|\n\t\tuniq_id ^= element\n\tend \n\n\treturn uniq_id\nend",
"def first_non_repeating(input)\n input_array = input.chars\n index = 0\n input_hash = {}\n for char in input_array do\n # If it's not in the hash already\n if input_hash.key?(char)\n # add char as key to input_hash\n # increment 1 to value of the char key in input_hash\n input_hash[char] += 1\n else\n # create a new key in input_hash and assign value as one\n input_hash[char] = 1\n end\n end\n p input_hash.key(1)\nend",
"def find_unique_integer(id_array)\n unique_id = 0 \n id_array.each do |id|\n unique_id ^= id\n end\n\n return unique_id\nend",
"def generate_random_array \n big_array = []\n i = set_array_size.to_i\n \n while i >= 1 \n big_string = (0...50).map { ('a'..'z').to_a[rand(26)] }.join\n big_array << big_string\n i = i - 1 \n end\n big_array \n end",
"def lookuptable\n res = Hash.new\n (0..255).each do |c|\n res[c] = unscramble(c)\n end\n res\n end",
"def index(key, size)\n ascii_value = 0\n hash_key = 0\n\n key.split(\"\").each do |letter|\n ascii_value += letter.ord #Method to retrieve ascii\n end\n\n hash_key = ascii_value % size\n\n return hash_key\n end",
"def random_hash(size)\n characters = ('A'..'Z').to_a + (2..9).to_a - [ 'I', 'O' ]\n Array.new(size) { characters[ rand(characters.size) ] }.join\n end",
"def inject_evil_symbols(array)\n array.insert(\n rand(0..array.length),\n [rand(9999), 9999]\n ).flatten!\nend",
"def unoptimized_find_unique_integer(id_array)\n histogram = Hash.new(0)\n id_array.each do |id|\n histogram[id] += 1\n end\n histogram.keys.each do |key|\n return key if histogram[key] == 1\n end\n return nil\nend",
"def index(key, size)\n #sums up the ascii values of each char in a string\n code = key.sum\n return code % size\n end",
"def array_to_indices_hash(array)\n array.inject({}) {|hash,e| hash[hash.size] = e; hash }\n end",
"def index(key, size)\n #true_index = hash(key) % k\n code = 0\n key.split(%r{\\s*}).each do |letter|\n code += letter.ord \n end\n puts code\n return code % size\n\n end",
"def random_string_in(arr)\n return nil if arr.empty?\n index = random_number(0, arr.length-1)\n arr[index]\n end",
"def where_to_put_secret(index)\n (0...48).each do |b|\n if index[b] == 1\n return b\n end\n end\n # I = 0, this is the seed.\n 48\n end",
"def dupe_indices(array)\n #ht = Hash.new {|h,k| h[k]=[]}\n #ht[\"cats\"] << \"Jellicle\"\n #ht[\"cats\"] << \"Mr. Mistoffelees\"\n hash = Hash.new { |h,k| h[k]=[] }\n array.each_with_index do |char, i|\n hash[char] << i\n end\n \n # puts \"Hash b select form : #{b.select{|key, value| value < 200}}\\n\\n\n hash.select{ |k,v| v.length > 1}\n\n\nend",
"def my_uniq(arr)\n answer = Hash.new\n arr.each_with_index do |el, i|\n answer[el] = 1\n end\n answer.keys\nend",
"def to_indices_hash(arr)\n #::Hash[*(0..arr.length - 1).to_a.zip(arr).flatten]\n arr.inject({}) {|hash,e| hash[hash.size] = e; hash }\n end",
"def hashify(key)\n array = key.split('')\n count = array.count\n index = array.inject(0) do |object,char|\n object += char.ord ** count\n count -= 1\n object\n end\n index % 89\n end",
"def index(key, size)\n # Takes the string 'key', creates an array of individual characters (split), maps to an array of ascii values (map), and then sums them (reduce)\n # Reaminder from dividing above amount by array size produces the array index\n (key.split(//).map { |char| char.ord }.reduce(:+)) % size\n end",
"def test_hash_correct\n\t\n\t\tString test_array1 = '2|abb2|George>Amina(16):Henry>James(4):Henry>Cyrus(17):Henry>Kublai(4):George>Rana(1):SYSTEM>Wu(100)|1518892051.753197000|c72d'.split('|').map(&:chomp)\n\n\t\tx = test_array1[0].unpack('U*') + test_array1[1].unpack('U*') + test_array1[2].unpack('U*') + test_array1[3].unpack('U*')\n\t\tsum = 0\n\t\t# x.each { |i| puts x[i] }\n\t\t# x.delete(\"\")\n\t\tx.each { |i| sum += ((x[i].to_i ** 2000) * ((x[i].to_i + 2) ** 21) - ((x[i].to_i + 5) ** 3)) }\n\t\thash = (sum % 65536)\n\t\tputs hash.to_s(16)\n\t\t\n\t\ttest_array2 = '3|c72d|SYSTEM>Henry(100)|1518892051.764563000|7419'.split('|').map(&:chomp)\n\t\t\n\t\t# assert_equal test_str[2,2], '0|'\t\n\tend",
"def random_index(len)\n rand(1..len) - 1\nend",
"def uniqueness_dictionary\n [*(:A..:Z), *(:a..:z), *(0..9)].map(&:to_s)\n end",
"def hashit\n n = 0\t \n (\"A\"..\"Z\").each do |x|\n @rotor_hash[x] = @rotor_array[n]\n n += 1\n end \n return @rotor_hash\n end",
"def uniques(array)\n hash = Hash[array.map {|x| [x, nil]}]\n print hash.keys\nend",
"def from_index\n Indexer.index[probably_unique_id]\n end",
"def weighted_random_index(array)\n idx = rand(array.length)\nend",
"def my_uniq(arr)\n hashed = arr.map {|value| [value, arr.count(value)]}.flatten\n return Hash[*hashed].keys\nend",
"def hash()\n #This is a stub, used for indexing\nend",
"def create_key_a\n @key_chars[0..1].join.to_i\n end",
"def my_uniq(arr)\n hash = Hash.new(0)\n arr.each {|el| hash[el] = 1} #value doesnt matter this case\n hash.keys\nend",
"def hash()\n #This is a stub, used for indexing\n end",
"def hashit\n n = 0\n Chars.split(\"\").each do |x|\n @rotor_hash[x] = @rotor_array[n]\n n += 1\n end \n @rotor_hash\n end",
"def my_uniq(arr)\n hsh = Hash.new(0)\n arr.each do |el|\n hsh[el] += 1\n end\n hsh.keys\nend",
"def generate_unique_key\n # not doing uppercase as url is case insensitive\n charset = ::Shortener.key_chars\n (0...::Shortener.unique_key_length).map{ charset[rand(charset.size)] }.join\n end",
"def rand_index\n SecureRandom.random_number(size)\n end",
"def unique_elements(array)\n hash = Hash.new(0)\n array.each { |ele| hash[ele] += 1 }\n\n hash.keys\nend",
"def uniq_integer(input_array)\n unique = 0\n input_array.each do |num|\n unique = unique ^ num\n end\n\n unique\nend",
"def ifind_magic(arr)\n return false if arr.size == 0\n s = arr[0]\n e = arr[-1]\n magic_arr = []\n i = 0\n while s < e\n return magic_arr if arr[i] != i\n if arr[i] == i\n magic_arr[i] = i\n end\n i += 1\n end\nend",
"def gen_first_path(path_length)\n # we will now generate an array with path_length number of elements\n # the elements will be randomly selected numbers from (1.. path_length ^ 2)\n # to avoid duplicate numbers we will kepp track of which ones have already been used\n # in another local array\n\n used = []\n\n path = {}\n\n path_length.times do |k, v|\n random = gen_uniq_rand(path_length ** 2, used)\n used << random\n path[random] = 0\n end\n\n path\nend",
"def create_index1(word)\n word.chars.sort!.join\n end",
"def random_entry(arr)\n arr[rand(arr.size)]\n end",
"def first_unique_char(s)\n\n hash = Hash.new(0)\n\n s.each_char.with_index(0) {|char, i|\n if hash[char] != nil\n hash[char] = hash[char] + 1\n else\n hash[char] = 1\n end\n\n # p hash\n }\n\n s.each_char.with_index(0) {|char, i|\n if hash[char] == 1\n return i\n end\n }\n return -1\n\nend",
"def generate_unique_id\n Digest::SHA256.hexdigest unique_id_elements.join\n end",
"def get_auto_hash\n hash = get_hash(Time.now.to_s)\n zeros = rand(5)\n (0..zeros).each do |z|\n hash[z] = \"0\"\n end\n\n return hash\nend",
"def dupe_indices(arr)\n idxs = Hash.new { |h, k| h[k] = [] }\n \n arr.each_with_index do |ele, i|\n idxs[ele] << i\n end\n\n return idxs.select { |ele, arr| arr.length > 1 }\nend",
"def initialize(seed)\n @index = 0\n @mt = []\n @mt[0] = seed\n (1...ARRAY_LENGTH).each do |i|\n @mt[i] = (2 **32 -1) & (INIT_CONST * (@mt[i-1] ^ (@mt[i-1] >> 30)) + i)\n end\n end",
"def make_artist unique_index\n artist_name = (0...8).map{ 65.+(rand(26)).chr }.join\n return \"INSERT INTO artists VALUES (#{rand(500)}, '#{artist_name}');\"\nend",
"def SHA256 arr\n Digest::SHA256.digest(arr.map(&:chr).join).bytes\nend",
"def unique_in_order(string)\n string.each_char.with_index.reduce([]) do |arr, (el, i)|\n if el == string.chars[i+1]\n arr\n else\n arr << el\n end\n end\nend",
"def array_to_hash(array) \n count=0\n\n hash = Hash.new\n (array.length).times do \n hash[count+1] = array[count]\n count += 1\n end\n return hash\n end",
"def magic_slow(arr)\n arr.each_with_index do |val, index|\n return index if val === index\n end\nend",
"def array_gen(hash)\n array = []\n hash.each do |key, value|\n value.times do\n array << key.to_s\n end\n end\n return array\nend",
"def index(key, size)\n ascii = 0\n \n key.each_byte do |x|\n ascii += x\n end\n \n return ascii % size\n end",
"def unique_elements(arr)\n hash = Hash.new(0)\n arr.each {|el| hash[el] += 1}\n return hash.keys\n\nend",
"def weighted_random_index(array)\n\nend",
"def unique_in_order(iterable) \n# create an empty array\ncontent = []\n\n # check each letter/number of `iterable` \n for e in (0..iterable.length()-1) \n\n# compare current element to previous element\n# if array is empty\n if e == 0 or \n# \n# if current element is not the same with previous element, push current index to content array\n iterable[e] != iterable[e-1] \n content.push(iterable[e])\n end\n end\n# return new content array\n return content\nend",
"def unique_index\n @unique_index\n end",
"def get_first_recurring_char(arr)\n hash = {}\n\n arr.each do |ele|\n key = ele.is_a?(Integer) ? ele.to_s : ele.to_sym\n return ele if hash[key]\n\n hash[key] = 'e'\n end\n 'The array is unique. No recurring character!!!'\nend",
"def index(key, size)\n char_value = 0\n # Adds together all of the ASCII values for each character into char_value.\n for letter in key.chars do\n char_value += letter.ord\n end\n # Increments char_value until its length equals desired size.\n until char_value.to_s.length == 7\n char_value*=11\n end\n\n return char_value%size\n end",
"def tiles_array_to_hash(array)\n tiles = Hash.new\n i = 0\n until i == array.length\n tiles[array[i]] = i\n i += 1\n end\n tiles\nend",
"def index(key, size)\n hash_code = 0\n key.each_byte do |c|\n hash_code += c\n end\n hash_code % @size\n end",
"def unique_elements(arr)\n hash = Hash.new(0)\n arr.each { |ele| hash[ele] += 1}\n hash.keys\nend",
"def my_uniq(arr)\n counter = Hash.new(0)\n arr.each do |x|\n counter[x] += 1\n end\n counter.keys\nend",
"def Unique(string)\n\n # assumes alphabet of size 128\n return false if string.length > 128\n \n hash={}\n \n for i in 0..string.length-1\n return false if hash[string[i]] \n hash[string[i]]=true\n end\n \n \nreturn true\n\nend",
"def hashing(i)\n \n return ALPHABET[0] if i == 0\n hash = ''\n base = ALPHABET.length\n while i > 0\n hash<< ALPHABET[i.modulo(base)]\n i /= base\n end\n hash.reverse\n end",
"def index_of(item)\n hash_value = 0\n item.each_byte { |byte| hash_value += byte }\n hash_value % @table.size\n end",
"def index(key, size)\n ascii_sum = 0\n key.split(\"\").each do |word|\n ascii_sum += word.ord\n end\n ascii_sum % size\n end",
"def index(key, size)\n sum = 0\n\n key.split(\"\").each do |char|\n if char.ord == 0\n next\n end\n\n sum = sum + char.ord\n end\n\n\n sum % size\n\n end",
"def magic_slow(arr)\n arr.each_with_index do |val, index|\n if val === index\n return index\n end\n end\nend",
"def using_uniq(array)\n\n \nend",
"def initialize(seed=42)\n @arr = []\n @size = 0\n r = Random.new(seed)\n @cardinality = 1000\n @hash_a = ((r.rand(PRIME_NUMBER-1)+1)%PRIME_NUMBER) % @cardinality\n @hash_b = r.rand(PRIME_NUMBER)\n end",
"def make_hash\n chars = (\"a\"..\"z\").to_a + (\"A\"..\"Z\").to_a + (\"0\"..\"9\").to_a\n string = \"\"\n 20.times do\n string << chars[rand(chars.size-1)]\n end\n hash = Digest::SHA2.hexdigest(string)\n end",
"def hash\n value = 0\n my_rows = @rows\n r_size = my_rows.size\n for i in 0..r_size-1 do\n a_row = my_rows[i]\n a_size = a_row.size\n for j in 0..a_size-1 do\n value ^= a_row[j].hash\n end\n end\n return value\n end",
"def index(key, size)\n sum = 0\n\n key.split(\"\").each do |char|\n if char.ord == 0\n next\n end\n\n sum = sum + char.ord\n end\n\n\n sum % size\n end",
"def index(key, size)\n sum = 0\n\n key.split(\"\").each do |char|\n if char.ord == 0\n next\n end\n\n sum = sum + char.ord\n end\n\n\n sum % size\n end",
"def yale_row_as_hash i\n h = yale_nd_row(i, :hash)\n return h if i >= self.shape[1] || self[i,i].nil? || self[i,i] == 0\n h[i] = self[i,i]\n end",
"def Hash_Func( str )\n hash = 0\n i = 0\n while i < str.length\n c = str[i]\n hash = hash * 31 + c.ord\n i = i + 1\n end\n hash = hash.abs\n return PaddGUID( hash )\n end",
"def non_repeating_char_index(string) \n hash = {}\n\n string.length.times do |i|\n if !hash.has_key?(string[i])\n hash[string[i]] = 1\n else\n hash[string[i]] += 1\n end\n end\n\n char = hash.select { |char, occurence| occurence == 1}\n .map { |char, occurence| char }[0]\n\n return string.index(char) \nend",
"def test_index_one_repeated_word\n #assert false # bogus assert -- remove or comment out\n @concordance.index!(['zero','zero','zero'])\n assert_equal({'zero'=>[1]},@concordance.hash)\n end",
"def hard(string)\n hasher = KnotHash.new(256, string.bytes + [17, 31, 73, 47, 23])\n 64.times { hasher.round }\n hasher.hash\nend",
"def test_index_array\r\n\t\tarr = [\"a\", \"b\", \"c\", \"a\", \"b\", \"d\", \"c\"]\r\n\t\tassert_equal({\"a\"=>[0,3], \"b\"=>[1,4], \"c\"=>[2,6], \"d\"=>[5]}, arr.find_values_index())\r\n\tend",
"def first_uniq_char(s)\n hash_table = {}\n (0..s.length-1).each do |i|\n if hash_table.include? (s[i])\n hash_table[s[i]] = hash_table[s[i]] + 1\n else\n hash_table[s[i]] = 1\n end\n end\n\n (0..s.length-1).each do |i|\n if hash_table[s[i]] == 1\n return i\n end\n end\n return -1\nend",
"def key_for_string str\n Digest::MD5.hexdigest(str).to_i(16) & KEY_MAX\n end",
"def generate_unique_key\n\n # @TODO:need to update the algo. Right now it's very simple algo\n length = self.url.length\n rand(36**length).to_s(36)\n end",
"def index(key, size)\n sum = 0\n\n key.split(\"\").each do |char|\n if char.ord == 0\n next\n end\n\n sum = sum + char.ord\n end\n\n sum % size\n end",
"def random_key\n o = [('a'..'z'), ('A'..'Z')].map(&:to_a).flatten\n (0...8).map { o[rand(o.length)] }.join\n end",
"def my_uniq(arr)\n \n output = []\n hash = Hash.new(false)\n \n arr.each do |x|\n output << x if !hash[x]\n hash[x] = true\n end\n output\n end",
"def index(key, size)\n value = ascii_value(key) % size\n return value\n end",
"def unique(arr)\n uniq = Hash.new(0)\n arr.each { |x| uniq[x] += 1 }\n uniq.select { |k, v| v == 1 }.keys\nend",
"def find_unique_elements (arr)\n n = Hash.new(0)\n return_array = []\n arr.each do |element|\n n[element] += 1\n end\n n.each_pair { |k,v| \n if v == 1\n return_array << k\n end\n }\n \n return return_array\nend",
"def generate_key(size = 6)\n charset = %w{ 2 3 4 6 7 9 A C D E F G H J K L M N P Q R T V W X Y Z}\n (0...size).map{ charset.to_a[rand(charset.size)] }.join\nend",
"def gimme(input_array)\n input_array.index(input_array.sort[1])\nend",
"def unique_elements(arr)\n my_hash = Hash.new(0)\n arr.each do |element|\n my_hash[element] += 1\n end\n return my_hash.keys\nend",
"def index\n @array = [45, 6, 32, 0]\n end"
] |
[
"0.63834584",
"0.62408745",
"0.6144398",
"0.60990644",
"0.60592127",
"0.6046242",
"0.6042425",
"0.60280126",
"0.5992942",
"0.5906817",
"0.5871855",
"0.5838909",
"0.58250093",
"0.5816861",
"0.57664907",
"0.57522625",
"0.5751663",
"0.57400036",
"0.5729892",
"0.57130796",
"0.5708408",
"0.5702879",
"0.5701204",
"0.5680978",
"0.5671231",
"0.56584144",
"0.5617152",
"0.5611801",
"0.5610672",
"0.561063",
"0.55887157",
"0.55598044",
"0.55557996",
"0.55414414",
"0.5535717",
"0.5534053",
"0.5521148",
"0.55131483",
"0.55084664",
"0.5503477",
"0.54947627",
"0.54916143",
"0.54911286",
"0.548662",
"0.5466709",
"0.5454102",
"0.5448943",
"0.5443764",
"0.5438011",
"0.5430865",
"0.5430254",
"0.5429421",
"0.5427968",
"0.54235995",
"0.5419781",
"0.54174817",
"0.54173523",
"0.5416028",
"0.54103553",
"0.5406169",
"0.5406004",
"0.5404584",
"0.53965044",
"0.53905773",
"0.5390543",
"0.53884065",
"0.53835976",
"0.53773254",
"0.5368964",
"0.53638625",
"0.53603643",
"0.53570557",
"0.5352038",
"0.53505045",
"0.5349038",
"0.5315847",
"0.53112984",
"0.53011656",
"0.52983326",
"0.5293961",
"0.5293099",
"0.5293099",
"0.52866644",
"0.5285471",
"0.528464",
"0.52834845",
"0.5269769",
"0.5268261",
"0.5268076",
"0.526779",
"0.5267541",
"0.5266755",
"0.52570695",
"0.5256897",
"0.5252947",
"0.5251492",
"0.52492195",
"0.5247806",
"0.52443707",
"0.5239008",
"0.5237722"
] |
0.0
|
-1
|
Simple method to return the number of items in the hash
|
def size
@items.length
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def size\n return @hash.length\n end",
"def length\n hash.keys.length\n end",
"def size\n @hash.size\n end",
"def size\n @hash.size\n end",
"def size\n @hash.size\n end",
"def size\n @hash_array.length\n end",
"def size\n @hash_array.length\n end",
"def size\n @hash_table.keys.length\n end",
"def size\n keys.size\n end",
"def length\n @internal_hash.length\n end",
"def count\n @hash_tags.count\n end",
"def count(list)\n list.each do |hash|\n total += 1\n end\n return total\n end",
"def length()\n return self.keys.get_length()\n end",
"def size\n @keys.size\n end",
"def hlen(key); end",
"def hlen(key); end",
"def length()\n return @i_keys.get_length()\n end",
"def length\n keys.length\n end",
"def num_keys\n end",
"def length\n return @ghash.length\n end",
"def value_count(hash, value)\n hash.select { |_k, v| v == value }.length\nend",
"def test_Hash_InstanceMethods_size\n\t\th={1=>'a', 2=>'b', 3=>'c'}\n\t\tassert_equal(3, h.size)\n\tend",
"def count\r\n items.size\r\n end",
"def size\n @hash.size + @converted.size\n end",
"def hash_size\n hashref_size * num_hashes\n end",
"def length\n @driver_instance.count_list_value(@key)\n end",
"def nitems() end",
"def count_objects\n count = 0\n @objects.keys.each do |key|\n count += @objects[key].length\n end\n\n return count\n end",
"def size\n @redis.llen @key\n end",
"def item_count\n item_values.values.compact.sum { |v| v.is_a?(Array) ? v.size : 1 }\n end",
"def size\n @buckets.length\n end",
"def get_size\n @buckets.length\n end",
"def count_items\n @items.size\n end",
"def item_count\n @items.length \n end",
"def size\n self.data.keys.size\n end",
"def size\n @index.keys.uniq.count\n end",
"def length\n @results.keys.length\n end",
"def item_count\n @items.length\n end",
"def count\n redis { |conn| conn.llen(key) }\n end",
"def count; @value.size; end",
"def size\n @store.keys.count { |k| Time.now - @store[k].stamp < @lifetime }\n end",
"def count\n @item_list.size\n end",
"def count\n values.inject(0){|m, v| m + v.length}\n end",
"def size\n @keys.length - 1\n end",
"def size(hash1=self.orderJSON)\n sum = 0\n unless hash1.class == Hash\n hash1 = eval(hash1)\n end\n hash1.each do |k1,v1|\n v1.each do |k2,v2|\n sum += v2.to_i\n end\n end\n return sum \n end",
"def length\n stash.length\n end",
"def value_count(hash, value)\n count = 0\n hash.each { |elem| count += 1 if elem[1]==value }\n count\nend",
"def key_count\n $capitals.keys.length\nend",
"def size\n @items.count\n end",
"def size\n @items.count\n end",
"def count\n each.size\n end",
"def count(data)\n return data.length\n end",
"def size\n return @items.size\n end",
"def counts\n count = Hash.new(0)\n self.each{|ele| count[ele] += 1}\n count\n end",
"def size\n return @items.length\n end",
"def size\n return @items.length\n end",
"def size\n return @items.length\n end",
"def size\n return @items.length\n end",
"def size\n return @items.length\n end",
"def size\n return @items.length\n end",
"def size\n return @items.length\n end",
"def size\n entries.length\n end",
"def hit_count\n item_hash.deep_find(:hit_count, 0)\n end",
"def hashref_size\n hashptr_size + length_size\n end",
"def size\n\t\treturn @items.size\n end",
"def size\n return @items.size\n end",
"def size\n entries.size\n end",
"def size\n @references_to_keys_map.count do |_, ref|\n ref.object\n end\n end",
"def count_items(name)\n @items[name].size\n end",
"def size\n counter = 0\n @items.each do |item|\n if item.nil?\n counter += 1\n else\n counter += item.length - 1\n end\n end\n counter\n end",
"def size\n return @items.length\n end",
"def print_counts(hash)\n hash.each { |key, count| puts \"#{key} -- #{count}\\n---------\\n\" }\nend",
"def occurences_count\n\t\t\t\t\t\tHash.new(0).tap do |result|\n\t\t\t\t\t\t each { |item| result[item] += 1 }\n\t\t\t\t\t\tend\n\t\t\t\tend",
"def count\n @data.size\n end",
"def item_count()\n @names.count\n end",
"def size\n @count\n end",
"def size\n @count\n end",
"def customer_pet_count(customer_hash)\n return customer_hash[:pets].length\nend",
"def num_buckets\n @store.length\n end",
"def size\n data.values.inject(0){|m,v| m+=v.size}\n end",
"def length\n each.count\n end",
"def count\n to_a.size\n end",
"def count\n to_a.size\n end",
"def size\n items.size\n end",
"def size\n items.size\n end",
"def item_count\n collection.length\n end",
"def size\n @clients.keys.length\n end",
"def my_count\n if block_given?\n num = 0\n self.my_each{|item| num += 1 if yield(item)}\n num\n else\n # if no block given return size of array\n self.length\n end\n end",
"def size\n\n @items.size\n end",
"def count\n @map.count\n end",
"def size\n entries.length\n end",
"def count\n items.compact.count.to_d\n end",
"def item_count\n @collection.length\n end",
"def size\n @size ||= (@key_map || @row || []).size\n end",
"def count\n @obj['count'].to_i\n end",
"def size\n entries.size\n end",
"def size\n entries.size\n end",
"def cardinality\n redis.hget(bucket_key, RedisBackend::COUNT_FIELD).to_i\n end",
"def size\n @items.length\n end",
"def size\n @items.length \n end",
"def size\n count = 0\n @properties.each do |gid, values|\n if ! values.empty?\n count += 1\n end\n end\n return count\n end"
] |
[
"0.82830465",
"0.82106954",
"0.8109915",
"0.8109915",
"0.8109915",
"0.79695594",
"0.79695594",
"0.78124315",
"0.77486163",
"0.76849425",
"0.7678069",
"0.7656559",
"0.7636084",
"0.76298493",
"0.761464",
"0.761464",
"0.7574793",
"0.7569945",
"0.7478816",
"0.7444118",
"0.7398974",
"0.7347107",
"0.7325141",
"0.73046833",
"0.7278303",
"0.7254247",
"0.72418344",
"0.72181946",
"0.7218174",
"0.7212672",
"0.7163285",
"0.7155209",
"0.71543235",
"0.7141862",
"0.7141228",
"0.7114565",
"0.7113586",
"0.70941246",
"0.70929605",
"0.7078681",
"0.7075524",
"0.70673853",
"0.704924",
"0.7045759",
"0.7036195",
"0.7036063",
"0.70260674",
"0.7013333",
"0.7007178",
"0.7007178",
"0.6999955",
"0.69869804",
"0.69839865",
"0.69832903",
"0.6981746",
"0.6981746",
"0.6981746",
"0.6981746",
"0.6981746",
"0.6981746",
"0.6981746",
"0.698101",
"0.6957832",
"0.69537604",
"0.6951404",
"0.69499755",
"0.6942363",
"0.69395435",
"0.6938698",
"0.6935908",
"0.6935669",
"0.6932399",
"0.6930644",
"0.69240755",
"0.69203275",
"0.6903333",
"0.6903333",
"0.6896567",
"0.68949735",
"0.6894421",
"0.68883306",
"0.6887863",
"0.6887863",
"0.6878182",
"0.6878182",
"0.687759",
"0.6873718",
"0.6871754",
"0.6845873",
"0.6842765",
"0.683874",
"0.68387157",
"0.68368727",
"0.6836297",
"0.6833241",
"0.68303066",
"0.68303066",
"0.68206984",
"0.68202174",
"0.68190515",
"0.6816045"
] |
0.0
|
-1
|
Little kludge for getting badlyspecified keys
|
def delete_with_key(key)
real_key = @original_properties.keys.find { |k| k.to_s == key.to_s }
@original_properties.delete(real_key)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def unmatched_keys; end",
"def missing_keys; end",
"def possible_keys(key); end",
"def hkeys(key); end",
"def hkeys(key); end",
"def keys(*) end",
"def stringified_keys; end",
"def key_coercions; end",
"def keys; end",
"def keys; end",
"def keys; end",
"def keys; end",
"def keys; end",
"def keys; end",
"def keys; end",
"def keys; end",
"def keys; end",
"def keys() end",
"def from_keys\n end",
"def sorted_keys; end",
"def keys(*_arg0, &_arg1); end",
"def key_types; end",
"def key_types; end",
"def custom_hash_keys(hash)\n keys_array = []\n hash.each { |k,v| keys_array << k }\n keys_array\nend",
"def keypair; end",
"def keypair; end",
"def keypair; end",
"def keypair; end",
"def keypair; end",
"def get_first_key(hash)\n return \nend",
"def key_types=(_arg0); end",
"def child_keys() []; end",
"def keys\n return self.keySet.to_a\n end",
"def key_variants; end",
"def stringify_keys; end",
"def stringify_keys; end",
"def stringify_keys; end",
"def _key(*args); args.hash; end",
"def keys(index_name = T.unsafe(nil)); end",
"def get_all_keys\n keys = Hash.new()\n @packages.each do |key, value|\n keys[key] = value.stringpool_keystrings.values\n end\n\n return keys\n end",
"def transform_keys(&block); end",
"def exchange_keys; end",
"def exchange_keys; end",
"def rekey_as_needed; end",
"def keys(pattern = T.unsafe(nil)); end",
"def keys\n end",
"def keys\n end",
"def keys\n end",
"def list_keys()\n # TODO\n end",
"def convert_key(key); end",
"def convert_key(key); end",
"def convert_key(key); end",
"def keygens; end",
"def key_data; end",
"def key_data; end",
"def transform_keys!(&block); end",
"def symbolize_keys; end",
"def read_key; end",
"def keys\n end",
"def flexible_key; end",
"def unrecognized_keys(expected, given)\n given.keys - expected\n end",
"def getKeys(data_keys)\r\n data_keys[0].keys\r\n end",
"def key_ids\n @keys.keys\n end",
"def to_key; nil end",
"def keys_from_hash\n if @keys.find_index(@option.value)\n return @keys.find_index(@option.value)\n else\n return @keys.first\n end\n end",
"def keys(glob = T.unsafe(nil)); end",
"def default_keys; end",
"def get_min_key()\n \n end",
"def key=(_arg0); end",
"def key=(_arg0); end",
"def key=(_arg0); end",
"def missing_keys(route, parts); end",
"def hash_key(name); end",
"def user_keys\n @user_keys ||= begin\n _keys = keys || {}\n ret = Hash[_keys.map { |k, v| [clean_identifier(k), v] }]\n if ret.keys.count != _keys.keys.count\n Logger.warn \\\n \"Duplicate public key identifiers were detected in #keys.\"\n end\n ret\n end\n end",
"def coerce_keys(*attrs); end",
"def unused_keys\n keys - fetched_keys\n end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def key; end",
"def keys\n list = []\n each_key{|key| list << key}\n list\n end",
"def grab_keys(hsh)\n keys = []\n hsh.each_pair do |key,value|\n keys << key\n end\n keys\nend",
"def list_keys\n @keydict.keys\n end",
"def extract_key(ctx); end",
"def keys\n @navigable_map.key_set.to_a\n end"
] |
[
"0.75716215",
"0.7399028",
"0.7315766",
"0.710568",
"0.710568",
"0.70761955",
"0.70651656",
"0.6999975",
"0.69367516",
"0.69367516",
"0.69367516",
"0.69367516",
"0.69367516",
"0.69367516",
"0.69367516",
"0.69367516",
"0.69367516",
"0.686182",
"0.6825731",
"0.6755162",
"0.67340595",
"0.669156",
"0.669156",
"0.66393423",
"0.6499799",
"0.6499799",
"0.6499799",
"0.6499799",
"0.6499799",
"0.6482973",
"0.64829165",
"0.64814615",
"0.6479299",
"0.6459772",
"0.6459161",
"0.6459161",
"0.6459161",
"0.644239",
"0.6429671",
"0.6395827",
"0.6394437",
"0.6388269",
"0.6388269",
"0.63840514",
"0.638",
"0.6371252",
"0.6371252",
"0.6371252",
"0.63568103",
"0.63554376",
"0.63554376",
"0.63554376",
"0.63537556",
"0.6347564",
"0.6347564",
"0.63171977",
"0.63142097",
"0.6312708",
"0.6305672",
"0.63048464",
"0.6291027",
"0.6281585",
"0.6277446",
"0.62624264",
"0.62615335",
"0.6259301",
"0.62553596",
"0.6251523",
"0.6249586",
"0.6249586",
"0.6249586",
"0.6248493",
"0.6247558",
"0.62411827",
"0.6233628",
"0.61952484",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61925435",
"0.61823493",
"0.6176846",
"0.61696744",
"0.6159523",
"0.6150995"
] |
0.0
|
-1
|
Get the part of the the uri that can be used as a label
|
def label_for(uri)
if(uri =~ /xpointer/)
'An Xpointer'
else
uri_fragment(uri)
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def name()\n if bound?\n return bound_name\n end\n if label && label.match(/[a-zA-Z][a-zA-Z0-9_]*/) != nil\n return label\n end\n return uri.split(/(\\/|#)/).last\n end",
"def parsed_label_uri(value)\n value.split('$').first\n end",
"def local_part_uri\n self.uri.match(/^http:\\/\\/.+?(\\/[^#]+)/)\n return $1\n end",
"def find_id(uri)\n Addressable::URI.parse(uri).basename\n end",
"def path_label\n set_slug unless slug\n slug.gsub(/\\W/, \"_\").slice(0, MAX_LABEL_LENGTH)\n end",
"def path_label\n set_slug unless slug\n slug.gsub(/\\W/, \"_\").slice(0, MAX_LABEL_LENGTH)\n end",
"def uri\n @uri.to_s\n end",
"def get_profile_name(uri)\n uri.host + uri.path\n end",
"def uri\n attributes.fetch(:uri)\n end",
"def uri\n attributes.fetch(:uri)\n end",
"def extract_pid(uri)\n URI(uri).path.split('/').last\n end",
"def path(uri)\n path, _ = path_and_name(uri)\n path\n end",
"def titleized\n self.uri.local_name.titleize\n end",
"def get_name(uri)\n KnownUri.by_uri(uri).name\n end",
"def url\n uri.to_s\n end",
"def uri\n read_attr :uri\n end",
"def titleized\n self.uri.local_name.titleize\n end",
"def get_label(object_uri)\n\tlabel_triple = AAT.find_one({\n\t\t\"s\" => object_uri,\n\t\t\"p\" => GETTY_PREF_LABEL\n\t\t})[\"o\"]\n\tliteral_label = AAT.find_one({\n\t\t\"s\" => label_triple,\n\t\t\"p\" => GETTY_LABEL_LITERAL\n\t\t})[\"o\"]\n\treturn literal_label\nend",
"def to_s\n uri.to_s\n end",
"def uri_to_name(uri)\n uri = URI.parse(uri)\n path = uri.path\n path = path.chomp(File.extname(path))\n path = path.chomp('trunk')\n File.join(uri.host,path).split('/').reverse.join('.')\n #path.split('/').reverse.join('.')\n end",
"def object_key_from_uri(uri)\n uri.split('/')[3..-1].join('/')\n end",
"def uri\n @uri\n end",
"def uri\n @uri\n end",
"def getURI()\n return @uri.to_s\n end",
"def to_s\n @uri\n end",
"def path\n @uri.path\n end",
"def url\n uri.to_s\n end",
"def to_s\n uri\n end",
"def value2uri(label, value)\n elements_url = label['links']['elements']\n uri = \"#{elements_url}?filter=#{URI::encode value}\"\n resp = GoodData.get uri\n elements = resp['attributeElements']['elements']\n if elements && !elements.empty?\n matching = resp['attributeElements']['elements'].find { |e| e['title'] == value }\n return matching['uri'] if matching\n end\n raise \"Value '#{value}' not found for label '#{label}'\"\n end",
"def uri_path\n __getobj__.uri.path\n end",
"def full_uri\n\n return nil unless self.uri\n self.uri.index('/') ? self.uri : \"/defs/#{self.uri}\"\n end",
"def url_content\n urn\n end",
"def get_uri\n unless self.uri == nil\n return self.uri\n else \n return repository.generate_uri(title)\n end\n end",
"def uri\n @uri\n end",
"def uri\n @uri\n end",
"def to_s\n @uri\n end",
"def resolved_uri; end",
"def name\n $0.split(\"/\").last\n end",
"def uri\n return @uri\n end",
"def uri\n return @uri\n end",
"def categorize_uri(str)\n regex = /\\.+/ # really simple host regex to thwart unwanted strings\n str = \"http://#{str}\" unless str.to_s =~ %r{\\Ahttps?://}\n uri = URI.parse(str.to_s)\n path = uri.path.chomp('/')\n return :unknown if (uri.host =~ regex).nil?\n\n path.empty? ? :host : :url\n rescue URI::InvalidURIError\n :unknown\n end",
"def extract_id_uri\n @id_uri = @meta.at_xpath('./a:identification/a:FRBRWork/a:FRBRuri', a: NS)['value']\n empty, @country, @nature, date, @num = @id_uri.split('/')\n\n # yyyy-mm-dd\n @year = date.split('-', 2)[0]\n end",
"def humanish(uri)\n uri.path.split('/').last.gsub('.git', '')\n end",
"def extract_base_url(uri)\n root = uri.split(\"/\",4)\n root[0] + \"//\" + root[2]\n end",
"def build_uri\n unless title.blank?\n self.uri = title.mb_chars.normalize(:d).split(//u).reject { |e| e.length > 1\n }.join.gsub(\"\\n\", \" \").gsub(/[^a-z0-9\\-_ \\.]+/i, '').squeeze(' '\n ).gsub(/ |\\.|_/, '-').gsub(/\\-+/, '-').gsub(/(^\\-)|(\\-$)/, '').downcase\n end\n end",
"def headsign\n url.to_s =~ /information\\/([a-z]+)\\//\n $1\n end",
"def fetch_namespace(resource)\n uri = Addressable::URI.parse(resource.to_s)\n \n if(uri.fragment != nil)\n return \"#{uri.host}#{uri.path}\"\n elsif(resource.to_s.include?(\"bio2rdf.org\"))\n #template = Addressable::Template.new(\"http://{host}/{first}:{fragment}\")\n #template = template.extract(uri)\n ns = resource.to_s.split(\":\")\n return ns[0..(ns.length-1)].join(\":\")\n #return \"#{template[\"host\"]}#{template[\"first\"]}\"\n end\n end",
"def uri_host; end",
"def to_s\n uri_string\n end",
"def label_as_filename\n str = label.to_s\n if str.empty?\n str.object_id\n else\n str.sub(/\\W+/, '-')\n end\n end",
"def uri\n self + \"\"\n end",
"def uri\n self + \"\"\n end",
"def path_part(part)\n @_path_parts ||= Blog::UriTemplates.extract_params(blog_data.source_template, path)\n @_path_parts[part.to_s]\n end",
"def to_s\n self.uri.to_s\n end",
"def object\n\t\tlink = self.links.find {|link| link.rlabel[0] == ?O } or return nil\n\t\treturn link.rword.sub( /\\.[np]$/, '' )\n\tend",
"def uri\n N::URI.new(self[:uri])\n end",
"def uri\n N::URI.new(self[:uri])\n end",
"def name\n @address_book_info['uri']\n end",
"def uri_segment(str)\n # pchar - pct-encoded = unreserved / sub-delims / \":\" / \"@\"\n # unreserved = ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\n # sub-delims = \"!\" / \"$\" / \"&\" / \"'\" / \"(\" / \")\" / \"*\" / \"+\" / \",\" / \";\" / \"=\"\n str.gsub(%r{[^A-Za-z0-9\\-._~!$&'()*+,;=:@]}n) {\n '%' + $&.unpack(\"H2\")[0].upcase\n }\n end",
"def full_path\n uri.request_uri\n end",
"def full_title\n # if used default namespaces -> remove from full title\n if (self.namespace == '101') or (self.namespace == 'Concept')\n self.title\n else\n # else use normal building of full url\n self.namespace + ':' + self.title\n end\n end",
"def pdns_pathname(uri)\n require 'pathname'\n require 'uri'\n Pathname.new(URI.parse(uri).path)\nend",
"def to_s\n @uri.to_s\n end",
"def to_s\n @uri.to_s\n end",
"def path\r\n url.gsub(/https?:\\/\\/[^\\/]+\\//i, '').scan(/([^&]+)/i).first().first()\r\n end",
"def uri(image)\n image.dig('medium', 'uri')\n end",
"def url\n uri\n end",
"def url\n uri\n end",
"def label(label)\n response = @mailer.label(label)\n @current_folder = response.split[0]\n return response\n end",
"def get_name(url)\n (url.match('features\\/(.*)\\z') || [])[1]\n end",
"def to_label\n publisher_namespace.to_s + '/' + type_path.to_s + ' (' + title.to_s + ')'\n end",
"def path\n @uri.request_uri\n end",
"def name_parser(uri)\n base_uri = uri.dup\n File.basename(base_uri, '.*')\n end",
"def uri; end",
"def uri; end",
"def uri; end",
"def uri; end",
"def uri; end",
"def uri; end",
"def uri; end",
"def uri; end",
"def uri; end",
"def uri; end",
"def uri; end",
"def uri; end",
"def uri_normalizer; end",
"def get_corresponding_file_base_name\n return File.basename(@URL)\n end",
"def full_uri\n \"#{host_uri}#{uri}\"\n end",
"def get_filename\n File.basename(url)[/(?:(?!\\?|#).)*/] || File.basename(url)\n end",
"def rdf_label\n label = super\n unless parentFeature.empty? or RDF::URI(label.first).valid?\n #TODO: Identify more featureCodes that should cause us to terminate the sequence\n return label if top_level_element?\n\n parent_label = (parentFeature.first.kind_of? ActiveTriples::Resource) ? parentFeature.first.rdf_label.first : []\n return label if parent_label.empty? or RDF::URI(parent_label).valid? or parent_label.starts_with? '_:'\n label = \"#{label.first} >> #{parent_label}\"\n end\n Array(label)\n end",
"def part\n \"#{path.chomp('.part')}.part\"\n end",
"def obj_id\n uri.split('/').last\n end",
"def obj_id\n uri.split('/').last\n end",
"def referent_identifier ref, label = nil\n safe_join [\n (label.if_present || ref.model_name.human.split.first),\n homelink(ref),\n ': '.html_safe\n ]\n end",
"def id(string)\n return if string.blank?\n\n URI(string)\n .path\n .split(\"/\")\n .last\n .to_i\n end",
"def title_for(source)\n (source[N::DCNS.title].first || source[N::RDF.label].first || N::URI.new(source.uri).local_name.titleize)\n end",
"def name\n parent_uri = self.parent.uri.to_s\n if not parent_uri.end_with?(\"/ROs/\")\n # Evil hack\n parent_uri += \"/ROs/\"\n end\n return URI.parse(parent_uri).route_to(self.uri.to_s).to_s\n end",
"def test_local_name\n assert_equal(\"master\", N::URI.new(\"http://somethingelse.com/master\").local_name)\n assert_equal(\"slave\", N::URI.new(\"http://somethingelse.com/master#slave\").local_name)\n assert_equal(\"chicken\", N::URI.new(\"http://somethingelse.com/animals/chicken\").local_name)\n end",
"def human_url\n return data()['project_uri']\n end",
"def permalink\n return \"#{uri}\"\n end"
] |
[
"0.7736041",
"0.7680642",
"0.68481475",
"0.6714549",
"0.6619614",
"0.6619614",
"0.654376",
"0.63899124",
"0.6317598",
"0.6317598",
"0.62558824",
"0.62350285",
"0.6225079",
"0.61797917",
"0.61721426",
"0.6148535",
"0.61412793",
"0.6140119",
"0.6130022",
"0.6111617",
"0.60595304",
"0.6057475",
"0.6057475",
"0.60522497",
"0.6048218",
"0.6045515",
"0.6043469",
"0.60061353",
"0.6005163",
"0.5988715",
"0.59875184",
"0.59732527",
"0.5970066",
"0.5949119",
"0.5949119",
"0.5948731",
"0.59161824",
"0.59101903",
"0.5907914",
"0.5907914",
"0.59013295",
"0.59003824",
"0.5874752",
"0.58736527",
"0.5872678",
"0.5835893",
"0.58241385",
"0.5818961",
"0.581741",
"0.581593",
"0.5815465",
"0.5815465",
"0.58111453",
"0.5810404",
"0.58092743",
"0.5803836",
"0.5803836",
"0.5797618",
"0.57892656",
"0.57884777",
"0.57754135",
"0.5764358",
"0.57635003",
"0.57635003",
"0.57478386",
"0.57439566",
"0.5743747",
"0.5743747",
"0.57435447",
"0.57425976",
"0.57345814",
"0.57305735",
"0.5730083",
"0.57155913",
"0.57155913",
"0.57155913",
"0.57155913",
"0.57155913",
"0.57155913",
"0.57155913",
"0.57155913",
"0.57155913",
"0.57155913",
"0.57155913",
"0.57155913",
"0.57115877",
"0.5705791",
"0.57048553",
"0.5690115",
"0.5689529",
"0.56837463",
"0.56810486",
"0.56810486",
"0.5666161",
"0.5655382",
"0.5644855",
"0.564319",
"0.564194",
"0.563688",
"0.56352717"
] |
0.670635
|
4
|
Indicates if the lookup has completed yet or not.
|
def completed?
return @complete
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def complete?\n @complete\n end",
"def complete?\n @complete\n end",
"def complete?\n completed_at && response\n end",
"def complete?\n true\n end",
"def complete?\n @gapi.job_complete\n end",
"def complete?\r\n @is_complete\r\n end",
"def complete?\n true\n end",
"def complete?\n result? || error?\n end",
"def complete?\n false\n end",
"def completed?\n @completed\n end",
"def finished?()\n #This is a stub, used for indexing\n end",
"def completed?\n @completed\n end",
"def crawling_complete?\n @completed\n end",
"def complete?\n return state == \"complete\"\n end",
"def marked_as_complete?\n get[state.to_s] and get[state.to_s].to_sym == :complete\n end",
"def completed?\n completed\n end",
"def complete?\n self.complete\n end",
"def completed?\n return @completed\n end",
"def finished?\n\t\tfinished_on.present?\n\tend",
"def finished?\n\t\tfinished_on.present?\n\tend",
"def complete?\n status == \"Completed\"\n end",
"def completed?\n\t\t\treturn request_status == REQUEST_STATUS['completed']\n\t\tend",
"def ready?\n self.result_payload(true).has_key?('finished_at')\n end",
"def completed?\n job_completed?\n end",
"def finished?\n @finished\n end",
"def finished?\n @finished\n end",
"def finished?\n @finished\n end",
"def finished?\n @finished\n end",
"def complete?\n complete == true\n end",
"def complete?\n end",
"def completed?\n @state.to_s =~ /finished|aborted|failed/\n end",
"def did_complete_transcoding?\n if variant_jobs.all? { |j| j.finished? }\n variant_jobs.any? { |j| j.failed? } ? false : true\n else\n false\n end\n end",
"def completed?\n !!completed\n end",
"def complete?\n finished? || cancelled? || failed? || job_failed? || timeout?\n end",
"def complete?\n status_code == 'OK'\n end",
"def complete?\n true\n end",
"def complete?\n true\n end",
"def completed?\n return true unless @state == PENDING_STATE\n @lock.lock\n begin\n @state != PENDING_STATE\n ensure\n @lock.unlock\n end\n end",
"def finished?\r\n @finished ||= false\r\n end",
"def finished?\n self.completed? || self.failed?\n end",
"def complete?\n self.state == 'complete'\n end",
"def complete?\n !pending?\n end",
"def completed?\n\t\t@completed\n\tend",
"def completed?\n @completed\n end",
"def completed?\n @completed\n end",
"def complete?\n !incomplete?\n end",
"def complete?\n !incomplete?\n end",
"def in_progress?\n result.nil?\n end",
"def finished?\n !!@finished\n end",
"def is_done?\n return @is_done\n end",
"def finished?\n true unless self.finished_on.nil?\n end",
"def complete?\n %w[success failure exception].include?(status)\n end",
"def completed?(refname)\n callref = CallableRef.new(refname)\n key = callref.dynamic? ? @calltable.resolve(callref).first : callref\n @cache.include?(key)\n end",
"def finished?\n FINAL_STATUSES.include?(transaction_status) || status == COMPLETED\n end",
"def complete?\n\tstatus == \"Completed\"\n end",
"def completed?\n status.completed?\n end",
"def finished?\n @finished == true\n end",
"def completed?\n @progress != 'PENDING'\n end",
"def completed?\n completed == '1'\n end",
"def completed?\n self.status == STATUS_COMPLETED\n end",
"def finished?\n\tfinished_on.present? \n\tend",
"def finished?\n @status[:description] == :finished\n end",
"def finished?\n\n end",
"def completed?\n !self.finished_at.nil?\n end",
"def done?\n @done\n end",
"def done?\n @done\n end",
"def on_completed?\n @kind == :on_completed\n end",
"def completed?(resource)\n raise CompletionCriteriaMissingError.new\n end",
"def finished?\n\t\t\tif @finished.nil? then\n\t\t\t\tfalse\n\t\t\telse\n\t\t\t\t@finished\n\t\t\tend\n\t\tend",
"def complete?\n if threaded?\n !running?\n else\n true\n end\n end",
"def done?\n return @done\n end",
"def complete?(env)\n hit_status(env).present?\n end",
"def complete?(env)\n hit_status(env).present?\n end",
"def complete?(env)\n hit_status(env).present?\n end",
"def finished?\n\t\tif @finished.nil? then\n\t\t\tfalse\n\t\telse\n\t\t\t@finished\n\t\tend\n\tend",
"def finished?\n super && response_received?\n end",
"def finished?\n super && response_received?\n end",
"def query_done?\n [\n Protocol::Beeswax::QueryState::EXCEPTION,\n Protocol::Beeswax::QueryState::FINISHED\n ].include?(@service.get_state(@handle))\n end",
"def finished?\n @state == STATE_FINISHED\n end",
"def finished?\n started? and threads.none?(&:status)\n end",
"def became_completed?\n completed_changed? && completed\n end",
"def complete_result?\n @result_count < 1000\n end",
"def finished?\n finished_at.present? && retried_good_job_id.nil?\n end",
"def complete?\n xml = @client.get_request(\"/services/search/jobs/#{@sid}\")\n doc = Nokogiri::XML(xml)\n text = doc.xpath(\"//s:key[@name='isDone']\").text\n text.to_i == 1\n end",
"def done?\n @done \n end",
"def check_for_job_completion\n self.job.check_for_completion if complete?\n end",
"def completed?\n self.state == :completed\n end",
"def finished?\n failed? or successful? or skipped?\n end",
"def isCompleted\r\n\t\t\t\t\treturn @completed\r\n\t\t\t\tend",
"def isCompleted\r\n\t\t\t\t\treturn @completed\r\n\t\t\t\tend",
"def journey_complete?\n false\n end",
"def finished?\n @end_time != nil\n end",
"def done?\r\n @done\r\n end",
"def done?\n !!status && (!immediate || called)\n end",
"def success?\n finished? and !exception\n end",
"def pedia_complete?\n return status == COMPLETE\n end",
"def done?\n if @complete == \"Item complete\"\n return \"Item complete\"\n else\n return \"Item incomplete\"\n end\n end",
"def finished?\n !@operations or @operations.empty?\n end",
"def completed?\n \t\tlatest_transaction.completed? unless transactions.empty?\n \tend"
] |
[
"0.7504753",
"0.750444",
"0.73906815",
"0.73713934",
"0.73474526",
"0.7307312",
"0.7298211",
"0.7214583",
"0.71979016",
"0.7174163",
"0.7168761",
"0.7125651",
"0.7124894",
"0.7118348",
"0.7082809",
"0.7053466",
"0.7035593",
"0.7035229",
"0.702824",
"0.702824",
"0.7014408",
"0.7009202",
"0.7008841",
"0.69937456",
"0.6982597",
"0.6982597",
"0.6982597",
"0.6982597",
"0.6980346",
"0.6978259",
"0.69760466",
"0.69494873",
"0.6944785",
"0.6939719",
"0.693524",
"0.69242054",
"0.69242054",
"0.69116145",
"0.68963826",
"0.68851256",
"0.6883638",
"0.68759286",
"0.6870898",
"0.68706",
"0.68706",
"0.6867546",
"0.6867546",
"0.6848065",
"0.6808277",
"0.6805103",
"0.6801076",
"0.6779747",
"0.6778892",
"0.6776734",
"0.6760318",
"0.67396575",
"0.6737163",
"0.67367494",
"0.673054",
"0.6727875",
"0.67277175",
"0.67194456",
"0.671695",
"0.66972893",
"0.66906786",
"0.66906786",
"0.66669863",
"0.6663497",
"0.6651098",
"0.664663",
"0.6646343",
"0.66413724",
"0.66413724",
"0.66413724",
"0.6639572",
"0.66390675",
"0.66390675",
"0.6635005",
"0.6632182",
"0.66302645",
"0.66270864",
"0.6624421",
"0.6618503",
"0.6613863",
"0.66131437",
"0.6612369",
"0.6610342",
"0.6603862",
"0.6596251",
"0.6596251",
"0.65928304",
"0.65916204",
"0.6589824",
"0.6580193",
"0.6575704",
"0.6556167",
"0.6555802",
"0.6555099",
"0.655452"
] |
0.74687296
|
3
|
This method does the actual permalink escaping.
|
def escape(string)
result = ((translation_to && translation_from) ? Iconv.iconv(translation_to, translation_from, string) : string).to_s
result.gsub!(/[^\x00-\x7F]+/, '') # Remove anything non-ASCII entirely (e.g. diacritics).
result.gsub!(/[^\w_ \-]+/i, '') # Remove unwanted chars.
result.gsub!(/[ \-]+/i, '-') # No more than one of the separator in a row.
result.gsub!(/^\-|\-$/i, '') # Remove leading/trailing separator.
result.downcase!
result.size.zero? ? random_permalink(string) : result
rescue
random_permalink(string)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create_permalink\n self.permalink = CGI.escape(self.name.gsub(' ', '_')) if self.name\n end",
"def escape_and_truncate_for_permalink(value)\n self.escape(value)[0...self.permalink_options[:param_size]]\n end",
"def escape_sitemap_url(url)\n CGI::escape(url)\n end",
"def create_permalink\n self.permalink = self.name.gsub(/\\s/, \"-\").gsub(/_/, '-').gsub(/[^\\w-]/, '').downcase\n end",
"def set_permalink\n self.permalink = title.downcase.gsub(/[^0-9a-z]+/,' ').strip.gsub(' ','-') if title\n end",
"def safe_escape(uri); end",
"def permalinked\n yield(self)\n end",
"def uri_escape\n CGI.escape(self)\n end",
"def permalink; end",
"def permalink; end",
"def uri_escape(input); end",
"def permalink\n return \"#{uri}\"\n end",
"def permalink(item)\n url = url_for(item)\n url.gsub!(/\\.html$/, '') #if url[0].chr == \"/\"\n \n return url\n end",
"def escape_url(url)\n add_anchor_to_url escape_path(url), get_anchor(url)\n end",
"def make_slug\n self.permalink = (self.permalink.downcase.gsub(/[^a-zA-Z 0-9]/, \"\")).gsub(/\\s/,'-') if self.permalink\n end",
"def permalink\n link = object.path.gsub(\"::\", \"%2F\")\n link.tr!(\"?\", \"%3F\")\n link.tr!(\"#\", \":\")\n\n \"#{RUBYDOC_URL}/#{link}\"\n end",
"def permalink_with_spaces\n return self.permalink.gsub(/[\"-\"]/, ' ').gsub(/[\"_\"]/, ' ')\n end",
"def escape_wiki_link(text)\n text.gsub( EXT_WIKI_WORD_REGEX ) do |wikiword_wbrackets|\n wikiword_wbrackets.gsub( ESCAPE_FOR_MARUKU ) { |w| '\\\\'+w }\n end\n end",
"def add_permalink_suffix(template, permalink_style); end",
"def permalink_style; end",
"def set_permalink\n self.name = self.name.strip\n self.permalink = self.name.gsub(/[^[:alnum:]]/,\"-\").downcase\n end",
"def permalink_with_spaces\n return self.permalink.gsub(/[\\-_]+/, ' ')\n end",
"def permalink_style=(_arg0); end",
"def regenerate_permalink!\n \n self.permalink = if respond_to?(:parent)\n if parent.nil?\n \"/\"\n else\n File.join(parent.permalink, slug)\n end\n else\n \"/#{slug}\"\n end\n \n end",
"def create_permalink\n \"#{self.name.latinize.to_ascii}-#{self.edition.latinize.to_ascii}\".gsub(/[^0-9A-Za-z|_\\- ]/,'')\n end",
"def escape_uri(s); Rack::Utils.escape(s); end",
"def permalinkify(string)\n string.\n gsub(/[^\\x00-\\x7F]+/, ''). # Remove anything non-ASCII entirely (e.g. diacritics).\n gsub(/[^\\w_ \\-]+/i, ''). # Remove unwanted chars.\n gsub(/[ \\-]+/i, '-'). # No more than one of the separator in a row.\n gsub(/^\\-|\\-$/i, ''). # Remove leading/trailing separator.\n downcase\n end",
"def escape(str)\n URI.escape str, /[:?\\/']/\nend",
"def to_param\n permalink\n end",
"def to_param\n permalink\n end",
"def check_and_escape(url)\n check url\n CGI.escape url\n end",
"def to_param\n permalink\n end",
"def permalink\n \"/#{object.permalink}\"\n end",
"def permalink_for_url\n if permalink =~ /^https?:\\/\\//\n permalink\n else\n permalink.sub /^([^\\/]?)/, '/\\1'\n end\n end",
"def to_param\n #'foo'\n #{id}-#{permalink}\"\n permalink\n end",
"def escape_link(link)\n link.gsub(' ', '%20')\n end",
"def to_param; self.permalink end",
"def to_param\n return permalink if to_param_returns_permalink\n super\n end",
"def generated_permalink; end",
"def copy_permalink_to_path\n self.path = (self.path.split('/')[0..-2] + [self.permalink]).join('/') \n end",
"def permalink_name\n name.to_s.gsub!(/[^\\x00-\\x7F]+/, '') # Remove anything non-ASCII entirely (e.g. diacritics).\n name.to_s.gsub!(/[^\\w_ \\-]+/i, '') # Remove unwanted chars.\n name.to_s.gsub!(/[ \\-]+/i, '-') # No more than one of the separator in a row.\n name.to_s.gsub!(/^\\-|\\-$/i, '') # Remove leading/trailing separator.\n end",
"def urlescape\n @@uri_parser ||= URI::RFC2396_Parser.new\n @@uri_parser.escape(self)\n end",
"def pretty_url\n Iconv.iconv(\"ASCII//IGNORE//TRANSLIT\", \"UTF-8\", self).join.sanitize\n rescue\n self.sanitize\n end",
"def handle_special_HYPERLINK(special)\n url = special.text\n gen_url url, url\n end",
"def escape(string); end",
"def unescape_link\n self.link = CGI.unescape(link) if self.link.present?\n end",
"def permalink\n \"/entries/#{slug}\"\n end",
"def uri_escape\n str = xml_escape.gsub(/\\+/, '+')\n str = str.gsub(/\\s/, '+')\n end",
"def permalink=(permalink)\n write_attribute(:permalink, permalink) if self.custom_permalink?\n end",
"def pre_escape_query(query)\n # have to include apostrophe in here too, even though it's NOT\n # in the docs reserved list (and does not generally require URI escaping,\n # in theory) -- still need to double escape it to avoid YBoss returning\n # ' in suggestions! \n #\n # Do not need to double escape spaces even though they do need URI escaping. \n #\n # We are telling it ONLY to escape our list of punctuation that causes\n # trouble for YBoss unless double-escaped. Which means it won't escape\n # diacritics and other non-latin. Which means the output is still UTF8, \n # but ruby URI.escape incorrectly tags it \"ascii\", which causes probelms\n # later with illegal bytes -- so we need to retag as UTF-8 \n return URI.escape(query, \"/?&;:@,$=%\\\"#*<>{}|[]^\\\\`()'\").force_encoding(\"UTF-8\")\n end",
"def handle_special_HYPERLINK(special); end",
"def set_permalink \n if parent.present?\n self.permalink = [parent.permalink, name.to_url ].join('/')\n else\n self.permalink = name.to_url \n end\n end",
"def to_url\n\t\treturn self.\n\t\t\tunaccent.\n\t\t\tstrip_tags.\n\t\t\tgsub(\" \", \" \").\n\t\t\tgsub(\"&\", \" \").\n\t\t\tdowncase.\n\t\t\tgsub(/[^a-z0-9\\.\\s,\\-_]/, \"\").\n\t\t\tgsub(/[\\.\\s,\\-_]+/, \"-\").\n\t\t\ttrim(\"-\")\n\tend",
"def before_create\n @attributes['permalink'] = \n title.downcase.gsub(/\\s+/, '_').gsub(/[^a-zA-Z_]+/, '')\n end",
"def create_permalink(separator = '_', max_size = 127)\n pull_meta_definition if self.meta_definition.nil?\n \n unless self.meta_definition.randomise_permalink?\n return '' if title.blank?\n # words to ignore, usually the same words ignored by search engines\n ignore_words = ['a', 'an', 'the', '?']\n ignore_re = String.new\n # building ignore regexp\n ignore_words.each { |word|\n ignore_re << word + '\\b|\\b'\n }\n ignore_re = '\\b' + ignore_re + '\\b' \n new_permalink = self.title.dup.gsub(\"'\", separator) \n new_permalink.gsub!(ignore_re, '') \n new_permalink.downcase!\n new_permalink.strip! \n new_permalink.gsub!(/[^a-z0-9]+/, separator) \n new_permalink = new_permalink.to(max_size) \n new_permalink.gsub!(/^\\\\#{separator}+|\\\\#{separator}+$/, '')\n else\n new_permalink = ActiveSupport::SecureRandom.hex(16)\n end\n \n write_attribute(:permalink, new_permalink)\n end",
"def escape_url(url)\n url.blank? ? nil : url.gsub(/\\./, '-dot-').gsub(/\\//, '-slash-')\n end",
"def to_slug\n #strip the string\n ret = self.strip\n \n #blow away apostrophes\n ret.gsub! /['`]/,\"\"\n \n # Reemplazamos tildes por normales\n ret = ret.html_encode\n ret.downcase!\n ret.gsub! /&/i, '_'\n ret.gsub! /&([a-z])acute;/i, '\\1'\n ret.gsub! /&([a-z])tilde;/i, '\\1'\n ret = ret.html_decode\n\n # @ --> at, and & --> and\n ret.gsub! /\\s*@\\s*/, \"_\"\n ret.gsub! /\\s*&\\s*/, \"_\"\n\n #replace all non alphanumeric, underscore or periods with underscore\n ret.gsub! /\\s*[^A-Za-z0-9\\.\\-]\\s*/, '_' \n \n #convert double underscores to single\n ret.gsub! /_+/,\"_\"\n \n #strip off leading/trailing underscore\n ret.gsub! /\\A[_\\.]+|[_\\.]+\\z/,\"\"\n \n return ret\n end",
"def permalink(post)\n date = Date.parse(post['date'])\n title = Ruhoh::Utils.to_url_slug(post['title'])\n format = post['permalink'] || config['permalink']\n\n if format.include?(':')\n filename = File.basename(post['id'], File.extname(post['id']))\n category = Array(post['categories'])[0]\n category = category.split('/').map {|c| Ruhoh::Utils.to_url_slug(c) }.join('/') if category\n\n url = {\n \"year\" => date.strftime(\"%Y\"),\n \"month\" => date.strftime(\"%m\"),\n \"day\" => date.strftime(\"%d\"),\n \"title\" => title,\n \"filename\" => filename,\n \"i_day\" => date.strftime(\"%d\").to_i.to_s,\n \"i_month\" => date.strftime(\"%m\").to_i.to_s,\n \"categories\" => category || '',\n }.inject(format) { |result, token|\n result.gsub(/:#{Regexp.escape token.first}/, token.last)\n }.gsub(/\\/+/, \"/\")\n else\n # Use the literal permalink if it is a non-tokenized string.\n url = format.gsub(/^\\//, '').split('/').map {|p| CGI::escape(p) }.join('/')\n end \n\n @ruhoh.to_url(url)\n end",
"def link_sanitizer; end",
"def link_sanitizer; end",
"def link_sanitizer; end",
"def to_param\n permalink_was\n end",
"def to_param\n permalink_was\n end",
"def escape(s)\n URI.encode_www_form_component(s)\n end",
"def permalink(page_data)\n format = page_data['permalink'] || collection.config['permalink']\n format ||= \"/:path/:filename\"\n\n url = if format.include?(':')\n title = Ruhoh::Utils.to_url_slug(page_data['title'])\n filename = File.basename(page_data['id'])\n category = Array(page_data['categories'])[0]\n category = category.split('/').map {|c| Ruhoh::Utils.to_url_slug(c) }.join('/') if category\n relative_path = File.dirname(page_data['id'])\n relative_path = \"\" if relative_path == \".\"\n data = {\n \"title\" => title,\n \"filename\" => filename,\n \"path\" => File.join(@pointer[\"resource\"], relative_path),\n \"relative_path\" => relative_path,\n \"categories\" => category || '',\n }\n\n uses_date = false\n %w{ :year :month :day :i_day :i_month }.each do |token|\n if format.include?(token)\n uses_date = true\n break\n end\n end\n\n if uses_date\n begin\n date = Time.parse(page_data['date'].to_s)\n rescue ArgumentError, TypeError\n Ruhoh.log.error(\n \"ArgumentError:\" +\n \" The file '#{ @pointer[\"realpath\"] }' has a permalink '#{ format }'\" +\n \" which is date dependant but the date '#{page_data['date']}' could not be parsed.\" +\n \" Ensure the date's format is: 'YYYY-MM-DD'\"\n )\n end\n\n data.merge!({\n \"year\" => date.strftime(\"%Y\"),\n \"month\" => date.strftime(\"%m\"),\n \"day\" => date.strftime(\"%d\"),\n \"i_day\" => date.strftime(\"%d\").to_i.to_s,\n \"i_month\" => date.strftime(\"%m\").to_i.to_s,\n })\n end\n\n data.inject(format) { |result, token|\n result.gsub(/:#{Regexp.escape token.first}/, token.last)\n }.gsub(/\\/+/, \"/\")\n else\n # Use the literal permalink if it is a non-tokenized string.\n format.gsub(/^\\//, '').split('/').map {|p| CGI::escape(p) }.join('/')\n end\n\n # Only recognize extensions registered from a 'convertable' module.\n # This means 'non-convertable' extensions should pass-through.\n if Ruhoh::Converter.extensions.include?(File.extname(url))\n url = url.gsub(%r{#{File.extname(url)}$}, '.html')\n end\n\n unless (page_data['permalink_ext'] || collection.config['permalink_ext'])\n url = url.gsub(/index.html$/, '').gsub(/\\.html$/, '')\n end\n\n url = '/' if url.empty?\n\n @ruhoh.to_url(url)\n end",
"def to_permalink(string)\n string.gsub(/[^\\w\\s\\-]/,'').gsub(/[^\\w]|[\\_]/,' ').split.join('-').downcase\n end",
"def escape_slug(string)\n string.gsub(/[^\\w]/,'_').gsub(/^_+|_+$/,'').downcase\nend",
"def escape(str); end",
"def fix_links_to_self(markdown)\n\n # they will be formatted like this, with no slashes in the URL [Article Title](file-name.md)\n markdown.gsub(/\\[.*?\\]\\(([^\\/]*?).md\\)/) {\n \"[[slug:#{$1}]]\"\n }\n end",
"def url_encode\n Rack::Utils.escape self\n end",
"def escape_content\n content.to_s.gsub(/&/, \"&\").gsub(/\\\"/, \""\").gsub(/>/, \">\").gsub(/</, \"<\") \n end",
"def url\n return @url if @url\n\n url = permalink ?\n if site.config['relative_permalinks']\n File.join(@dir, permalink)\n else\n permalink\n end :\n {\n 'lang' => self.lang,\n 'categories' => self.categories,\n 'basename' => self.basename,\n }.inject(template) { |result, token|\n result.gsub(/:#{token.first}/, token.last)\n }.gsub(/\\/\\//, '/')\n\n # sanitize url\n @url = url.split('/').reject { |part| part =~ /^\\.+$/ }.join('/')\n @url += '/' if url =~ /\\/$/\n @url.gsub!(/\\A([^\\/])/, '/\\1')\n @url\n end",
"def sanitize_data\n sanitize_permalink\n sanitize_name\n end",
"def permalink\n link(:perma)\n end",
"def escape_wildcards\n gsub(/\\\\/, '\\\\\\\\').gsub(/\\*/, '\\*')\n end",
"def fix_double_escape(escaped)\n escaped.gsub(/&([a-z]+|(#\\d+));/i) { \"&#{$1};\" }\n end",
"def permalink\n discussion.to_s.parameterize.split(\"-\").slice(0..4).join(\"-\")\n end",
"def likeEscape( str )\n str.gsub( \"\\\\\", \"\\\\\\\\\" ).gsub( \"%\", \"\\%\" ).gsub( \"_\", \"\\_\" )\n end",
"def html_escape(clean_me)\n clean_me.to_s.gsub(/[&\"<>]/) do |special|\n { '&' => '&',\n '>' => '>',\n '<' => '<',\n '\"' => '"' }[special]\n end\n end",
"def prep(text)\n text = text.gsub /(http[s]?:\\/\\/[^ \\t]+)[ \\t]?/, \"<a target=\\\"_BLANK\\\" href=\\\"\\\\1\\\">\\\\1</a> \"\n text = text.gsub /#([^ \\t<:\\.\\?!@#=\\-_]+)[ \\t]?/, \"<a target=\\\"_BLANK\\\" href=\\\"http://search.twitter.com/search?tag=\\\\1\\\">#\\\\1</a> \"\n text = text.gsub /@([^ \\t<:\\.\\?!@#=\\-_]+)[ \\t]?/, \"<a target=\\\"_BLANK\\\" href=\\\"http://twitter.com/\\\\1\\\">@\\\\1</a> \"\n end",
"def generate_permalink!\n self.permalink = fix_duplication(normalize(self.send(generate_from)))\n end",
"def set_permalink\n translations.each(&:set_permalink)\n end",
"def escape_redirect(url)\n uri = URI.parse(url)\n \"\".html_safe + uri.path + '?' + uri.query.html_safe\n end",
"def convert_links\n\n # fetch leaf content\n c = self.content\n\n # regexps\n # url = /( |^)http:\\/\\/([^\\s]*\\.[^\\s]*)( |$)/\n tag_regex = /( |^)#(\\w+)( |$)/\n user_regex = /( |^)@(\\w+)( |$)/\n \n #TODO: make sure no one is typing javascript into the field **IMPORTANT**\n\n #replace #tags with links to that tag search\n while c =~ tag_regex\n c.gsub! \"##{$2}\", \"<a href='/leaves?tagged=#{$2}'>##{$2}</a>\"\n self.has_tags = true\n end\n\n #replace @usernames with links to that user, if user exists\n while c =~ user_regex\n user = $2\n if User.find(user)\n c.sub! \"@#{$2}\", \"<a href='/users/#{$2}'>@#{$2}</a>\"\n end\n end\n\n #replace urls with links\n #while c =~ url\n #name = $2\n #c.sub! /( |^)http:\\/\\/#{name}( |$)/, \" <a href='http://#{name}' >#{name}</a> \"\n #end\n\n self.content = c\n\n end",
"def uri_escape(uri)\n URI::DEFAULT_PARSER.escape(uri).gsub('[', '%5B').gsub(']', '%5D')\n end",
"def escape(string)\n #This is a stub, used for indexing\n end",
"def escape_wildcards(unescaped)\n case ActiveRecord::Base.connection.adapter_name\n when \"Mysql2\".freeze\n # Necessary for MySQL\n unescaped.to_s.gsub(/([\\\\%_])/, '\\\\\\\\\\\\1')\n when \"PostgreSQL\".freeze\n # Necessary for PostgreSQL\n unescaped.to_s.gsub(/([\\\\%_.])/, '\\\\\\\\\\\\1')\n else\n unescaped\n end\n end",
"def generate_permalink\n self.permalink = fix_duplication(normalize(self.send(generate_from))) if permalink.blank?\n end",
"def encoded_url\n CGI.escape(url)\n end",
"def permalink\n url = @path.inject(:+).to_s\n\n Henshin.local? ? url[1..-1] : url\n end",
"def get_permalink(pagename)\n\t\tpagename.gsub(\" \", \"_\").downcase\n\tend",
"def get_permalink(pagename)\n\t\tpagename.gsub(\" \", \"_\").downcase\n\tend",
"def escape_wildcards(unescaped)\n case ActiveRecord::Base.connection.adapter_name\n when \"Mysql2\", \"PostgreSQL\"\n # Necessary for PostgreSQL and MySQL\n unescaped.to_s.gsub(/([\\\\|\\%|.])/, '\\\\\\\\\\\\1')\n else\n unescaped\n end\n end",
"def escape(value)\n URI.escape(value, Regexp.new(\"[^#{URI::PATTERN::UNRESERVED}]\"))\n end",
"def latex_escape(s)\n quote_count = 0\n s.to_s.\n gsub(/([{}_$&%#])/, \"__LATEX_HELPER_TEMPORARY_BACKSLASH_PLACEHOLDER__\\\\1\").\n gsub(/\\\\/, BACKSLASH).\n gsub(/__LATEX_HELPER_TEMPORARY_BACKSLASH_PLACEHOLDER__/, BS).\n gsub(/\\^/, HAT).\n gsub(/~/, TILDE).\n gsub(/\"/) do\n quote_count += 1\n quote_count.odd? ? %{\"`} : %{\"'}\n end\n end",
"def fix_url\n self.url = UrlNormalizer.normalize_entry_url self.url, self\n end",
"def escape(s)\n s.gsub(/[&<>｀]/, \"&\" => \"&\", \"<\" => \"<\", \">\" => \">\", \"｀\" => \"`\")\n end",
"def url_escape(string)\n return '' if string.blank?\n\n string.gsub(/([^ a-zA-Z0-9_.-]+)/n) do\n '%' + $1.unpack('H2' * $1.size).join('%').upcase\n end.tr(' ', '+')\n end",
"def set_permalink\n if parent_id.nil?\n self.permalink = name.to_url if permalink.blank?\n else\n parent_taxon = Taxon.find(parent_id)\n self.permalink = [parent_taxon.permalink, (permalink.blank? ? name.to_url : permalink.split('/').last)].join('/')\n end\n end",
"def escape_query(query)\n # backslash escape doesn't seem to work\n #query.gsub(/([\\\\\\(\\)\\:])/) do |match|\n # \"\\\\#{$1}\"\n #end\n query.gsub(/([\\\\\\(\\)\\:])/, ' ')\n end"
] |
[
"0.70940995",
"0.6773647",
"0.6441132",
"0.6398594",
"0.6386641",
"0.6367014",
"0.6326879",
"0.6289178",
"0.62712276",
"0.62712276",
"0.6237689",
"0.6231297",
"0.6218325",
"0.61943936",
"0.618468",
"0.604984",
"0.6023654",
"0.59924155",
"0.5983261",
"0.5961688",
"0.595736",
"0.58783084",
"0.58216953",
"0.58190453",
"0.57968575",
"0.5790303",
"0.57735574",
"0.575588",
"0.57523334",
"0.57523334",
"0.5745812",
"0.57445204",
"0.5720172",
"0.57088053",
"0.5703759",
"0.5698379",
"0.5692759",
"0.56848985",
"0.5656479",
"0.56437904",
"0.5643128",
"0.56118596",
"0.56069934",
"0.5592493",
"0.55782413",
"0.5560885",
"0.5549455",
"0.55272967",
"0.55191535",
"0.5508506",
"0.54994637",
"0.5499345",
"0.5494316",
"0.5494189",
"0.54937595",
"0.5485371",
"0.5476603",
"0.5475777",
"0.54735434",
"0.54735434",
"0.54735434",
"0.54731333",
"0.54731333",
"0.5464833",
"0.54565936",
"0.54346913",
"0.5431843",
"0.5421596",
"0.5413705",
"0.54051125",
"0.5404292",
"0.5397934",
"0.5385493",
"0.5371582",
"0.5368197",
"0.53591",
"0.53537107",
"0.53397363",
"0.531927",
"0.53144807",
"0.5294625",
"0.5290575",
"0.528975",
"0.527598",
"0.52749187",
"0.5269446",
"0.5266169",
"0.526169",
"0.5257378",
"0.52566344",
"0.5248761",
"0.5248761",
"0.52378917",
"0.52334046",
"0.5227613",
"0.5226061",
"0.52258563",
"0.52186",
"0.5215291",
"0.52139974"
] |
0.60101897
|
17
|
Create a new Redirect instance if the fields have been changed
|
def create_redirect_if_permalink_fields_changed
former = send(self.class.permalink_field)
current = PermalinkFu.escape(create_permalink_for(self.class.permalink_attributes))
attributes = {:model => self.class.name, :former_permalink => former, :current_permalink => current}
if !former.nil? && former != current
# If the model attributes are being rolled back to some older value, delete the old redirect
self.class.redirect_model.delete_all :model => self.class.name, :former_permalink => current
self.class.redirect_model.update_all ['current_permalink = ?', current], :current_permalink => former
self.class.redirect_model.create(attributes)
end
return former != current
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create_redirect_action\n if params[:redirect_from].strip.size == 0\n flash[:error] = \"Original URL cannot be empty\"\n return redirect_to \"/admin\"\n end\n if params[:redirect_to].strip.size == 0\n flash[:error] = \"New URL cannot be empty\"\n return redirect_to \"/admin\"\n end\n redirect = Redirect.create(:from => params[:redirect_from].strip, :to => params[:redirect_to].strip)\n redirect.save!\n flash[:notice] = \"New redirect created.\"\n return redirect_to \"/admin\"\n end",
"def set_redirect\n @redirect = Redirect.find(params[:id])\n end",
"def be_redirected\n BeRedirected.new\nend",
"def save_redirect\n return unless redirect_params.any?\n\n redirect = @question.redirect\n if redirect\n redirect.assign_attributes(redirect_params)\n redirect_params[:redirect_type] == 'destroy' ? redirect.destroy : redirect.save\n else\n return true if redirect_params[:redirect_type] == 'destroy'\n @question.build_redirect(redirect_params)\n @question.redirect.save\n end\n end",
"def create\n @redirect = Redirect.new(redirect_params)\n\n respond_to do |format|\n if @redirect.save\n format.html { redirect_to @redirect, flash: { success: 'Redirect was successfully created.' } }\n format.json { render :show, status: :created, location: @redirect }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @redirect.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_redirect\n @redirect = Redirect.find(params[:id])\n end",
"def create\n @redirect = Redirect.new(redirect_params)\n\n respond_to do |format|\n if @redirect.save\n format.html { redirect_to :admin_dashboard, notice: 'Redirect was successfully created.' }\n format.json { render :show, status: :created, location: @redirect }\n else\n format.html { render :new }\n format.json { render json: @redirect.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n super\n\n if !params[:redirect].blank?\n redirect_path = params[:redirect].gsub(/^\\//, \"\")\n path = Rails.application.routes.recognize_path(\"/#{redirect_path}\",\n :method => :get) rescue nil\n if path\n store_location_for(:user, \"/#{redirect_path}\")\n else\n logger.warn(\"Unrecognized post-signup path: #{redirect_path}\")\n end\n end\n end",
"def create\n @redirect = Redirect.new(redirect_params)\n authorize @redirect\n\n respond_to do |format|\n if @redirect.save\n format.html { redirect_to @redirect, notice: \"Redirect was successfully created.\" }\n format.json { render :show, status: :created, location: @redirect }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @redirect.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n submitted_url = url_params[:original_url]\n\n @url = Url.where(original_url: [submitted_url, \"http://#{submitted_url}\",\"http://www.#{submitted_url}\"]).first_or_initialize\n @url.assign_attributes(url_params)\n\n respond_to do |format|\n if @url.persisted?\n format.html {redirect_to @url, notice: \"We've already redirected this url. Check out the shortened url below.\"}\n format.json { render action: 'show', status: 200, location: @url }\n elsif @url.save\n format.html { redirect_to @url, notice: 'Url was successfully created.' }\n format.json { render action: 'show', status: :created, location: @url }\n else\n format.html { render action: 'new' }\n format.json { render json: @url.errors, status: :unprocessable_entity }\n end\n end\n end",
"def redirect_params\n params.require(:redirect).permit(:source, :redirect, :expiration, :status)\n end",
"def be_redirected_to(path)\n BeRedirected.new(path)\nend",
"def redirect\n # Does it exist?\n if url = Redirect.find_by_short_url(params[:id])\n # # Increment count\n # url.update_attributes(count: url.count + 1)\n # Add redirect to history\n RedirectHistory.create(redirect_id: url.id, notes: \"params: #{params}\")\n # Redirect\n redirect_to url.full_url\n else\n redirect_to redirects_path\n end\n end",
"def store_redirect\n if params.key?(:redirect)\n store_redirect_url_for(params[:redirect], request.referer)\n end\n end",
"def redirect?; end",
"def create\n @post302 = Post302.new(params[:post302])\n\n respond_to do |format|\n if @post302.save\n format.html { redirect_to(@post302, :notice => 'Post302 was successfully created.') }\n format.xml { render :xml => @post302, :status => :created, :location => @post302 }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @post302.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(entry_params)\n @redirect_location = session.delete(:return_to) || @entry\n super\n end",
"def create\n @url = Url.new(url_params)\n\n if @url.save\n redirect_to @url\n else\n render 'new'\n end\n end",
"def redirects; end",
"def create\n @redirect_log = RedirectLog.new(redirect_log_params)\n\n respond_to do |format|\n if @redirect_log.save\n format.html { redirect_to @redirect_log, notice: 'Redirect log was successfully created.' }\n format.json { render :show, status: :created, location: @redirect_log }\n else\n format.html { render :new }\n format.json { render json: @redirect_log.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n # create new address\n @new_address = UserAddress.create!(address_params)\n \n if session[:new_membership_path] == true\n @redirect_path = knird_preferred_new_membership_path\n elsif session[:new_trial_path] == true\n @redirect_path = knird_preferred_new_trial_path\n else\n @redirect_path = session.delete(:return_to)\n end\n \n # redirect \n redirect_to @redirect_path\n\n end",
"def create\n @firma = Firma.new(firma_params)\n @redirect_params = params[:redirect_params] ? params[:redirect_params] : (flash[:redirect_params] ? flash[:redirect_params] : @firma)\n\n respond_to do |format|\n if @firma.save\n flash[:success] = \"Firma angelegt\"\n format.html { redirect_to @redirect_params }\n format.json { render :show, status: :created, location: @firma }\n else\n format.html { render :new }\n format.json { render json: @firma.errors, status: :unprocessable_entity }\n end\n end\n end",
"def redirect_params\n params.require(:redirect).permit(:shop_id, :origin, :destination)\n end",
"def create\n # Creating the patient with present surgeon\n params[:patient][:owner_id] = devise_current_user.id.to_s\n patient = current_user.patients.new(patient_params)\n # Condition for checking the saved or not\n if patient.save\n # Check the condition of which url is present\n if params[:patient][:prev_url].present?\n # If prev present then navigate to the patients case form\n redirect_to new_patient_case_path(patient)\n else\n # redirect to the patients if prev url not present\n redirect_to patients_path\n end\n else\n # redirect to the same page of the patient new page\n redirect_to :back\n # if the record is not save then navigate to the same page and showing the flash\n flash.notice = \"Need fill out the Essential Fields\"\n end\n end",
"def set_redirect_log\n @redirect_log = RedirectLog.find(params[:id])\n end",
"def create\n @landing = Landing.new(params[:landing])\n if @landing.save\n redirect_to landings_path\n end\n end",
"def create\n @coupen = Coupen.new(coupen_params)\n respond_to do |format|\n #as in model the coupen is unique so if its try to duplicate then it will redirect to new page again.\n #the problem here is if 2 user demands it commonly then it might be a problem.so again in new for creating\n #here first i need to test weather an user changed an coupen value or not or not.if its changed then \n #redirect to new again with saying coupen value is invalid\n if params[:coupenvalue] == params[:coupen][:coupen]\n if @coupen.save\n format.html { redirect_to @coupen, notice: 'Coupen was successfully created.' }\n format.json { render action: 'show', status: :created, location: @coupen }\n else\n format.html { render action: 'new' }\n format.json { render json: @coupen.errors, status: :unprocessable_entity }\n end\n else\n format.html { redirect_to new_coupen_path,notice: 'Coupen was Invalid' }\n end\n end\n end",
"def create_new_customer \n @new_customer = Customer.new\n @new_customer.name = params[\"new_contact_name\"]\n @new_customer.email = params[\"contact_email\"]\n @new_customer.florist_id = session[\"found_florist_id\"]\n if @new_customer.save\n redirect_to \"/cust_edit/#{@new_customer.id}\" and return\n else\n render(:cust_new) and return\n end\n end",
"def redirect_after_create\n resources_url {}\n end",
"def redirect_log_params\n params.require(:redirect_log).permit(:old_url, :new_url, :rule, :status)\n end",
"def handle_create\n obj = model.new(nil, request)\n model.set_fields(obj, :new, request, model_params)\n model.hook(:before_create, request, obj)\n if model.save(obj)\n model.hook(:after_create, request, obj)\n request.set_flash_notice(\"Created #{model.class_name}\")\n redirect(:new, obj)\n else\n request.set_flash_now_error(\"Error Creating #{model.class_name}\")\n new_page(obj)\n end\n end",
"def redirect(object, commit)\n if commit.key?('_save')\n redirect_to([:admin, :travel, Agency.find(commit[:agency_id]), object], notice: actions_messages(object))\n elsif commit.key?('_add_other')\n redirect_to(\n send(\"new_admin_travel_agency_#{object.model_name.element}_path\"),\n notice: actions_messages(object)\n )\n end\n end",
"def update\n respond_to do |format|\n if @redirect.update(redirect_params)\n format.html { redirect_to @redirect, notice: \"Redirect was successfully updated.\" }\n format.json { render :show, status: :ok, location: @redirect }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @redirect.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_finalurl\n\t\tStore.all.each do |store_obj|\n\t\t\tif url.include?(store_obj.tracker_urlidentifier)\n\t\t\t\tself.store = store_obj\n\t\t \t\tself.finalurl = store.get_redirect_url(url, id)\n\t\t \t\tself.save!\n\t\t\tend\n\t\tend\n\tend",
"def new\n #si el status del capacities es referido\n if status_valid?('referido')\n @new_turn = Turn.new\n else\n redirect_to 'logins/my_turn', alert: 'No estas calificado para crear Turno'\n logger.debug \"Intento de Creación de Turno sin Calificar\"\n end\n end",
"def create\n super do |format|\n redirect_to collection_url and return if resource.valid?\n end\n end",
"def create\n super do |format|\n redirect_to collection_url and return if resource.valid?\n end\n end",
"def create\n super do |format|\n redirect_to collection_url and return if resource.valid?\n end\n end",
"def update\n respond_to do |format|\n if @redirect.update(redirect_params)\n format.html { redirect_to @redirect, flash: { success: 'Redirect was successfully updated.' } }\n format.json { render :show, status: :ok, location: @redirect }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @redirect.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @redirect.update(redirect_params)\n format.html { redirect_to @redirect, notice: 'Redirect was successfully updated.' }\n format.json { render :show, status: :ok, location: @redirect }\n else\n format.html { render :edit }\n format.json { render json: @redirect.errors, status: :unprocessable_entity }\n end\n end\n end",
"def redirect_from_params\n if params[:redirect_to]\n redirect_to params[:redirect_to]\n end\n end",
"def redirect_new_report!(options, params:, **)\n params['new_report'] == 'true' ? options['new_report'] = true : options['new_report'] = false\n true\n end",
"def redirect_after_model_created(model)\n url = caller_url\n if url\n redirect_to url\n else\n redirect_to model\n end\n end",
"def redirect_to options = {}\n @has_redirect = options\n end",
"def create\n redirect_to_full_path\n end",
"def set_redirect\n @redirect = policy_scope(Redirect).find(params[:id])\n authorize @redirect\n end",
"def create_curr_location \n if @@form_step == nil \n redirect_to root_path \n end\n if @@form_step == 1 \n @latitude = params[:latitude] \n @longitude = params[:longitude] \n @loc = params[:loc]\n @@request.lat_curr = @latitude \n @@request.long_curr= @longitude \n @@request.currentLoc= @loc\n redirect_to url_for(:controller => \"requests\", :action => \"home\")\n else \n @latitude = params[:latitude] \n @longitude = params[:longitude] \n @destination = params[:loc]\n @@request.lat_destination = @latitude \n @@request.long_destination= @longitude \n @@request.destination= @destination\n unless (@@request.long_curr == nil)\n @@request.distance = distance(@@request.long_curr,@@request.lat_curr,@@request.long_destination,@@request.lat_destination)\n end\n redirect_to url_for(:controller => \"requests\", :action => \"create_route\") \n\n end \n end",
"def create\r\n super do |format|\r\n redirect_to collection_url and return if resource.valid?\r\n end\r\n end",
"def create\r\n super do |format|\r\n redirect_to collection_url and return if resource.valid?\r\n end\r\n end",
"def create\r\n super do |format|\r\n redirect_to collection_url and return if resource.valid?\r\n end\r\n end",
"def create\r\n super do |format|\r\n redirect_to collection_url and return if resource.valid?\r\n end\r\n end",
"def redirect\n redirect_model = get_model(config['redirect_model_slug'])\n if redirect_model\n redirect_model.entries.each do |entry|\n rules = entry.custom_fields_recipe['rules']\n match = entry[rules.first['name']]\n redirect_url = entry[rules.last['name']]\n if controller.request.fullpath =~ /#{match}/\n match_data = /#{match}/.match(controller.request.fullpath)\n /#{match}/.named_captures.each do |key,value|\n redirect_url.gsub!(/\\$#{key}/, match_data[key])\n end\n controller.redirect_to redirect_url and return\n end\n end\n end\n end",
"def redirect(location, status = '302'); request.redirect(location, status); end",
"def redirect_params\n params.require(:redirect).permit(:code, :event_id, :evidence_id)\n end",
"def create\n @url = Url.create_update_with(url_params)\n @short_url = \"#{request.host_with_port}/#{@url.short_url}\"\n redirect_to root_path(short_url: @short_url)\n end",
"def new_with_redirect;\n\t\t@user=User.new;\n\t\treturn redirect_to auth_path(:facebook) if params[:with]==\"facebook\"\n\t\treturn redirect_to auth_path(:linkedin) if params[:with]==\"linkedin\"\n\t\tif !auth_hash.blank?\n\t\t\tif @user.facebook_info(auth_hash)=='mail missing'\n\t\t\t\tflash[:error]='Sign up failed, we need your email to sign you up'\n\t\t\t\tredirect_to root_path\n\t\t\tend\n\t\tend\n\tend",
"def create\n @location = Location.new(params[:location])\n \n \n\n if params[:client_id]\n @client = params[:client_id]\n #session[:client] = @client\n end\n\n if !params[:location][:contactlocations_attributes].blank?\n params[:location][:contactlocations_attributes].values.each do |contact|\n @contact = contact[:contact_id]\n #session[:contact] = @contact\n end\n end\n\n if params[:project_id]\n @project = params[:project_id]\n @contact = params[:contact_id]\n end\n\n if params[:country] \n \n if @contact \n if @client && !@project\n redirect_to foreign_locations_path(:client_id=>@client, :contact=>@contact)\n end\n\n if @project && @client \n redirect_to foreign_locations_path(:project_id=>@project, :contact=>@contact)\n end\n else\n if @client \n redirect_to foreign_locations_path(:client_id=>@client)\n end\n\n if @project \n redirect_to foreign_locations_path(:project_id=>@project)\n end\n end\n\n else \n\n respond_to do |format|\n if @location.save \n if !@contact.blank? \n \n if @client && !@project\n format.html { redirect_to edit_client_contact_path(@client, @contact) , notice: 'Location was successfully created.' } \n elsif @project && @client\n if params[:project_signing_authority] == 1\n Projectcontact.create!(:project_id=>@project, :contact_id=>@contact ) \n else\n Projectcontact.create!(:project_id=>@project, :contact_id=>@contact, :authority=>true) \n end\n format.html { redirect_to project_path(@project) , notice: 'Location was successfully created.' } \n else\n format.html { redirect_to edit_contact_path(@contact) , notice: 'Location was successfully created.' } \n end\n \n elsif !@project.blank?\n format.html { redirect_to project_path(@project) , notice: 'Location was successfully created.' } \n else \n format.html { redirect_to client_path(@client), notice: 'Location was successfully created.' } \n \n end\n \n format.json { render json: @location, status: :created, location: @location }\n\n else\n format.html { render action: \"new\" }\n format.json { render json: @location.errors, status: :unprocessable_entity }\n end\n end\n \n\n end\n end",
"def create\n referrer = Rails.application.routes.recognize_path(request.referrer)\n \n @url = Url.new(url_params)\n @error = nil\n result_url = Url.find_by(:long_url => @url[:long_url])\n\n respond_to do |format|\n if result_url.nil?\n max_id = Url.maximum(:id) || 0\n num = START_OFFSET + max_id + 1\n short_key = encode(num) \n @url[:short_url] = short_key\n\n if @url.save\n @new_url = @url\n @url = Url.new(:long_url => @new_url[:long_url], :short_url => @new_url[:short_url])\n if referrer[:action] == 'index'\n format.html { render :index }\n else\n format.html { redirect_to @new_url, notice: \"URL was successfully created.\"}\n end\n else\n @error = @url.errors.full_messages\n if referrer[:action] == 'index'\n format.html { render :index }\n else\n format.html { render :new }\n format.json { render json: @url.errors, status: :unprocessable_entity }\n end\n end\n else\n if referrer[:action] == 'index'\n @url[:short_url] = result_url[:short_url]\n format.html { render :index }\n else\n format.html { redirect_to result_url, notice: \"Existing URL. No URL is created.\" }\n end\n end\n end\n end",
"def redirect\n @order.assign_attributes(order_params)\n if @order.valid?\n Gocardless::RedirectFlowService::Initialize.run(@order) do |redirect_url|\n return redirect_to redirect_url\n end\n else\n @address = @order.address\n @product = @order.product.decorate\n @order = @order.decorate\n render 'signup/orders/confirm'\n end\n end",
"def filter_redirect; end",
"def filter_redirect; end",
"def redirect(object, commit)\n if commit.key?('_save')\n redirect_to([:admin, :travel, object], notice: actions_messages(object))\n elsif commit.key?('_add_other')\n redirect_to(\n send(\"new_admin_travel_#{object.model_name.element}_path\"),\n notice: actions_messages(object)\n )\n end\n end",
"def redirect(object, commit)\n if commit.key?('_save')\n redirect_to([:admin, :travel, object], notice: actions_messages(object))\n elsif commit.key?('_add_other')\n redirect_to(\n send(\"new_admin_travel_#{object.model_name.element}_path\"),\n notice: actions_messages(object)\n )\n end\n end",
"def redirect(object, commit)\n if commit.key?('_save')\n redirect_to([:admin, :travel, object], notice: actions_messages(object))\n elsif commit.key?('_add_other')\n redirect_to(\n send(\"new_admin_travel_#{object.model_name.element}_path\"),\n notice: actions_messages(object)\n )\n end\n end",
"def redirect(object, commit)\n if commit.key?('_save')\n redirect_to([:admin, :travel, object], notice: actions_messages(object))\n elsif commit.key?('_add_other')\n redirect_to(\n send(\"new_admin_travel_#{object.model_name.element}_path\"),\n notice: actions_messages(object)\n )\n end\n end",
"def redirect(object, commit)\n if commit.key?('_save')\n redirect_to([:admin, :travel, object], notice: actions_messages(object))\n elsif commit.key?('_add_other')\n redirect_to(\n send(\"new_admin_travel_#{object.model_name.element}_path\"),\n notice: actions_messages(object)\n )\n end\n end",
"def create\n @advance_search = AdvanceSearch.new(advance_search_params)\n\n respond_to do |format|\n if @advance_search.save\n if request.env['HTTP_REFERER'].include? overview_url\n format.html { redirect_to overview_url(:id=>@advance_search), notice: 'Search was successful'}\n else\n format.html { redirect_to spendings_url(:id=>@advance_search), notice: 'Advance search was successfully created.'}\n end\n # format.html { redirect_to :back,params:{:id=>@advance_search}, notice: 'Advance search was successfully created.' }\n format.json { render action: 'show', status: :created, location: @advance_search }\n else\n format.html { render action: 'new' }\n format.json { render json: @advance_search.errors, status: :unprocessable_entity }\n end\n end\n end",
"def copy_record\n obj = find_checked_items\n @refresh_partial = \"timeprofile_copy\"\n @redirect_id = obj[0]\n end",
"def redirect(options = {})\r\n end",
"def redirect(type, obj)\n if redir = model.redirect_for\n path = redir.call(obj, type, request)\n end\n\n unless path\n path = case type\n when :new, :delete\n type.to_s\n when :edit\n \"edit/#{model.primary_key_value(obj)}\"\n else # when :mtm_edit\n \"mtm_edit/#{model.primary_key_value(obj)}?association=#{params_association}\"\n end\n path = url_for(path)\n end\n\n request.redirect(path)\n nil\n end",
"def create\n @contact_page = ContactPage.new(contact_page_params)\n\n if @contact_page.save\n redirect_to contact_pages_path\n else\n render :new\n end\n end",
"def multicast_redirect_state\n super\n end",
"def legacy_redirect\n community = Community.where(\"lower(legacy_url) = ?\", params[:legacy_community_name].to_s.downcase).first\n \n if community\n redirect_to community, status: 301\n elsif college = College.where(\"lower(short_name) = ?\", params[:legacy_college_name].to_s.downcase).first\n redirect_to college, status: 301\n else\n flash[:notice] = \"The link you clicked is out of date! We couldn't figure out where you wanted to go...\"\n redirect_to listings_url, status: 301\n end\n end",
"def redirect_params options = {}\n options[:mode] = @mode\n options\n end",
"def redirects()\n merge(redirects: 'true')\n end",
"def seen!()\n self.redirects_count += 1\n self.last_redirect_at = Time.now\n end",
"def load_redirected_objects!\n if flash[:redirected_objects]\n flash[:redirected_objects].each do |instance_reference, attributes|\n object_instance = instance_variable_get(instance_reference)\n # Apply errors to instance\n set_errors_to_redirected_instance(object_instance, attributes[:errors])\n # Apply any params (ie: changed form fields to be corrected)\n set_params_to_redirected_instance(object_instance, attributes[:params])\n end\n end\n ensure\n flash.delete(:redirected_objects)\n end",
"def create_action\n if has_errors?\n render :new, options\n else\n redirect_to resource_location\n end\n end",
"def new\n @renewed = Purchase.find_by_id params[:renew]\n @purchase = Purchase.new\n @locations = Location.roots.order(:name)\n if @renewed\n @purchase.name = @renewed.name\n @purchase.responsible = @renewed.responsible\n @purchase.phone_number = @renewed.phone_number\n @purchase.fax = @renewed.fax\n @purchase.email = @renewed.email\n @purchase.ssn_code = @renewed.ssn_code\n @purchase.vat_code = @renewed.vat_code\n @purchase.address = @renewed.address\n @purchase.postal_code = @renewed.postal_code\n @purchase.city = @renewed.city\n @purchase.country = @renewed.country\n @purchase.includes_invoice = @renewed.includes_invoice\n @purchase.release_date = Time.zone.now\n @purchase.start_date = @renewed.expiration_date\n end\n end",
"def create\n @url = Url.new(url_params)\n @url.sanitize\n @url.current_ip = request.remote_ip\n if @url.new_url?\n respond_to do |format|\n if @url.save\n format.html { redirect_to shortened_path(@url.short_url), notice: 'Url was successfully created.' }\n format.json { render :show, status: :created, location: @url }\n else\n format.html { render :new }\n format.json { render json: @url.errors, status: :unprocessable_entity }\n end\n end\n else\n flash[:notice] = \"A short link for this URL is already in our database\"\n redirect_to shortened_path(@url.find_duplicate.short_url)\n end\n \n end",
"def create\n redirect_to pages_path\n end",
"def set_params_to_redirected_instance(instance, instance_params)\n ensure_redirected_params_are_safe!(instance_params)\n\n instance_params.each do |attribute, value|\n instance.public_send(\"#{attribute}=\", value)\n end\n end",
"def set_redirected_object!(instance_reference, instance, instance_params)\n ensure_redirected_params_are_safe!(instance_params)\n\n flash[:redirected_objects] ||= {}\n flash[:redirected_objects][instance_reference] = {\n errors: instance.errors.messages,\n params: instance_params\n }\n end",
"def create\n if not check_logged_in then\n return\n end\n \n if params[:plant][:id] then\n @personal_plant = PersonalPlant.new(params[:plant][:personal_plants_attributes][\"0\"])\n @personal_plant[:plant_id] = params[:plant][:id]\n \n respond_to do |format|\n if @personal_plant.save\n format.html { redirect_to @personal_plant, notice: 'Personal plant was successfully created.' }\n format.json { render json: @personal_plant, status: :created, location: @personal_plant }\n else\n format.html { render controller: \"personal_plant\", action: \"new\" }\n format.json { render json: @personal_plant.errors, status: :unprocessable_entity }\n end\n end\n else\n @plant = Plant.new(params[:plant])\n \n #@plant.personal_plants[0].save\n respond_to do |format|\n if @plant.save\n #I BELIEVE THIS GO_TO IS NOT RELEVENT ANYMORE, BUT NOT SURE\n @go_to = @plant\n \n if @plant[:created_from_user] then\n @go_to = new_personal_plant_path + '?plant_id=' + @plant[:id].to_s\n end\n\n if params[:plant][:created_from_garden_id].length > 0 then\n @go_to = new_personal_plant_path + '?garden_id=' + params[:plant][:created_from_garden_id] + CGI.unescapeHTML('&plant_id=') + @plant[:id].to_s\n end\n\n format.html { redirect_to @go_to, notice: 'Plant was successfully created.' }\n format.json { render json: @plant, 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\n end",
"def handle_new\n obj = model.new(request.params[model.link], request)\n model.hook(:before_new, request, obj)\n new_page(obj)\n end",
"def create\n redirect_to ctos_path :myLocation=>params[:myLocation],:radius=>params[:radius], :page=>params[:page]\n end",
"def new?\n\t\tcreate?\n\tend",
"def redirect_to=(value)\n @redirect_to = value\n end",
"def create\n @doco = Doco.new(params[:doco]) #to have something to send to template if an error in edit_input\n edit_check = edit_input('new')\n \n if edit_check == 'passed edits'\n @doco = Doco.new(params[:doco]) #create for save with param values after edit_input has filled in/tweaked\n respond_to do |format|\n if @doco.save\n flash[:notice] = 'Doco was successfully created.'\n format.html { redirect_to(@doco) }\n format.xml { render :xml => @doco, :status => :created, :location => @doco }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @doco.errors, :status => :unprocessable_entity }\n end\n end\n end\n end",
"def new\n @artist = Artist.new\n if params[:redirect]\n session[:redirect]=true\n end\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @artist }\n end\n end",
"def new\n # empty check\n redirect_to controller: :users, action: :new and return unless User::any?\n # set variables\n @user = User.new\n end",
"def create\n \n @finance_lead = FinanceLead.new(params[:finance_lead])\n if @finance_lead.save\n redirect_to @finance_lead\n else\n render 'new'\n end\n \n end",
"def create_landing\r\n\r\n end",
"def create\n @landing_page = LandingPage.new(admin_landing_page_params)\n\n respond_to do |format|\n if @landing_page.save\n format.html { redirect_to admin_landing_page_path(@landing_page), success: I18n.t('admin.basic.messages.created', model: 'Landing Page')}\n format.json { render :show, status: :created, location: @landing_page }\n else\n format.html { render :new }\n format.json { render json: @landing_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @url = Url.find_or_initialize_by(url_params)\n if @url.save\n redirect_to urls_path, notice: \"Url shortner is successfully created\"\n else\n render :new\n end\n end",
"def redirect_after_create\n redirect_to project_products_path(params[:project_id]) \n end",
"def create\n @pages = Page.new(pages_params)\n if @pages.save\n redirect_to pages_path\n else\n renders :new\n end\nend",
"def create\n @actividad = Actividad.new(actividad_params)\n @actividad.empresa_id = @current_empresa.id\n\n #Verificamos si la tarea ha podido ser guardado correctamente.\n \n if @actividad.save()\n redirect_to actividads_path, :notice => \"La actividad ha sido creada\";\n else\n render \"new\";\n end\n end",
"def redirect_ok; end",
"def redirect_ok; end"
] |
[
"0.6520001",
"0.6351845",
"0.6325829",
"0.6309564",
"0.62364286",
"0.6219673",
"0.6083324",
"0.5975588",
"0.5966061",
"0.59267414",
"0.57616824",
"0.5713381",
"0.5653719",
"0.562784",
"0.5589663",
"0.55734503",
"0.5546721",
"0.54753965",
"0.54564196",
"0.54424274",
"0.5435866",
"0.5409986",
"0.5407036",
"0.5393521",
"0.5378907",
"0.5378576",
"0.5366559",
"0.53620225",
"0.5345995",
"0.5341614",
"0.5338729",
"0.5331129",
"0.53309065",
"0.53234446",
"0.53183216",
"0.5317229",
"0.5317229",
"0.5317229",
"0.53123915",
"0.5308909",
"0.530017",
"0.52939993",
"0.52876794",
"0.52875996",
"0.5284991",
"0.5284546",
"0.5279579",
"0.5279048",
"0.5279048",
"0.5279048",
"0.5279048",
"0.52543277",
"0.52341396",
"0.52295804",
"0.5223984",
"0.5223606",
"0.52212924",
"0.5212792",
"0.52106667",
"0.52039933",
"0.52039933",
"0.5198251",
"0.5198251",
"0.5198251",
"0.5198251",
"0.5198251",
"0.51683515",
"0.5167324",
"0.51527643",
"0.51518744",
"0.5134064",
"0.5130123",
"0.5111221",
"0.5096993",
"0.5093627",
"0.50884795",
"0.50820214",
"0.50808704",
"0.50800246",
"0.5051041",
"0.5048516",
"0.50467896",
"0.50453174",
"0.5042285",
"0.50414276",
"0.5037281",
"0.5025374",
"0.5017367",
"0.50144064",
"0.5009509",
"0.5004581",
"0.5004424",
"0.5002916",
"0.49993283",
"0.49967617",
"0.49921536",
"0.49920622",
"0.49902025",
"0.4987357",
"0.4987357"
] |
0.7034233
|
0
|
Configure Girlfriend to suit your needs Girlfriend.configure do |config| config.name = 'Ruby' end Configurables: [name = String] Girlfriend's name [age = Integer]Girlfriend's age [hometown = String] Girlfriend's hometown [school = String] Girlfriend's school [hobbies = Array]Girlfriend's hobbies [reply = String]Girlfriend's default reply text
|
def configure
yield self
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def configure\n # Users to block instead of interacting with\n self.blacklist = ['mcamargo1997']\n\n # Range in seconds to randomize delay when bot.delay is called\n self.delay_range = 1..6\n\n @userinfo = {}\n @botinfo = {\n ENV[\"BOT_NAME_1\"] => BotInfo.new(ENV[\"BOT_NAME_1\"]),\n ENV[\"BOT_NAME_2\"] => BotInfo.new(ENV[\"BOT_NAME_2\"])\n }\n end",
"def configure\n # Consumer details come from registering an app at https://dev.twitter.com/\n # Once you have consumer details, use \"ebooks auth\" for new access tokens\n self.consumer_key = 't9g6TgrUYsZ4R5aeArsM2C36G' # Your app consumer key\n self.consumer_secret = 'olto6fNhfZz0CZwtx4uaFFpoyW88KG4LZnuaMFtWkvhgWq3897' # Your app consumer secret\n\n # Users to block instead of interacting with\n self.blacklist = ['']\n\n # Range in seconds to randomize delay when bot.delay is called\n self.delay_range = 1..6\n\t\n\t@userinfo = {}\n end",
"def greet\n self.say \"Hello, I am #{@config[:nick]}. I am the resident uber-bot. To learn more, type '.about'.\"\n end",
"def config(config = nil)\n if config.nil?\n return @config\n end\n\n @config = config\n\n @banner = \"Welcome to #{config['name']}!\\n\"\n @game_dir = Pathname.new(File.join(Dir.pwd, config['game'] || 'game')).cleanpath.to_s\n if !File.directory?(@game_dir)\n puts \"Game directory (#{config['game']} does not exist\"\n exit 0\n end\n\n if File.file?(File.join(@game_dir, 'text', 'welcome.txt'))\n @banner = File.read(File.join(@game_dir, 'text', 'welcome.txt'))\n end\n\n @compiler = SecondContract::Parser::Script.new\n @parser = Grammar.new\n @binder = SecondContract::IFLib::Sys::Binder.instance\n @archetypes = {}\n @pending_archetypes = SecondContract::Game::SortedHash.new(:archetype)\n @pending_qualities = SecondContract::Game::SortedHash.new(:mixins)\n @mixins = {}\n @verbs = {}\n @adverbs = {}\n @comm_verbs = {}\n @constants = config['constants'] || {}\n @characters = []\n @bindings = []\n @domains = {}\n\n @events = []\n\n @pending = []\n\n @message_parser = SecondContract::Parser::Message.new\n @message_formatter = SecondContract::Compiler::Message.new\n self\n end",
"def config\n {\n terminating_sex: :boy,\n percent_families_wanting_children: 0.75,\n chance_of_having_another_child: 0.25,\n min_num_of_families: 10,\n }\n end",
"def configure\n\n # Give the bot a handle to config and handler\n conf = @config\n\n # Configure the bot\n @bot = Isaac::Bot.new\n @bot.configure{|c|\n c.server = conf[:server]\n c.port = conf[:port]\n c.ssl = conf[:ssl]\n c.nick = conf[:nick]\n c.password = conf[:password]\n c.realname = conf[:name]\n\n c.environment = :production\n c.verbose = conf[:verbose] || false \n c.log = $log\n }\n\n end",
"def greets(name)\n puts \"hello #{name}, my name is #{@greeter_name}\"\n end",
"def configure_information\n @config[\"config\"][\"contact\"] = {}\n if @args.empty?\n @config[\"config\"][\"organization_name\"] = @prompt.ask(prompt_box(\"What is your organization\\'s name?\"), required: true)\n @config[\"config\"][\"organization_description\"] = @prompt.ask(prompt_box(\"What is your organization\\'s description?\"))\n @config[\"config\"][\"organization_domain\"] = @prompt.ask(prompt_box(\"What is your organization\\'s custom URL that you would like to host the app at? (ex. demo.perlmutterapp.com) Leave blank to use the default instead.\"))\n prefs = @prompt.multi_select(prompt_box(\"Please select contact preferences to configure for your users to view:\"), %W[email phone facebook twitter instagram website])\n if prefs.count != 0\n @config[\"config\"][\"contact\"][\"description\"] = @prompt.ask(prompt_box(\"Enter a description for your contact page:\"), default: \"Fill out the form to send us a message!\", required: true)\n end\n if prefs.include? \"email\"\n @config[\"config\"][\"contact\"][\"email\"] = @prompt.ask(prompt_box(\"What is your contact email?\"), default: @config[\"config\"][\"contact\"][\"email\"], required: true) { |q| q.validate :email, \"Invalid email\" }\n end\n if prefs.include? \"phone\"\n @config[\"config\"][\"contact\"][\"phone\"] = @prompt.ask(prompt_box(\"What is your contact phone?\"), default: @config[\"config\"][\"contact\"][\"phone\"], required: true)\n end\n if prefs.include? \"facebook\"\n @config[\"config\"][\"contact\"][\"facebook\"] = @prompt.ask(prompt_box(\"What is your Facebook account?\"), default: @config[\"config\"][\"contact\"][\"facebook\"], required: true)\n end\n if prefs.include? \"twitter\"\n @config[\"config\"][\"contact\"][\"twitter\"] = @prompt.ask(prompt_box(\"What is your Twitter account?\"), default: @config[\"config\"][\"contact\"][\"twitter\"], required: true)\n end\n if prefs.include? \"instagram\"\n @config[\"config\"][\"contact\"][\"instagram\"] = @prompt.ask(prompt_box(\"What is your Instagram account?\"), default: @config[\"config\"][\"contact\"][\"instagram\"], required: true)\n end\n if prefs.include? \"website\"\n @config[\"config\"][\"contact\"][\"website\"] = @prompt.ask(prompt_box(\"What is your external website?\"), default: @config[\"config\"][\"contact\"][\"website\"], required: true)\n end\n else\n @config[\"config\"][\"organization_name\"] = get_argument_value(\"org_name\", true, nil)\n description = get_argument_value(\"org_desc\", false, nil)\n unless description.nil?\n @config[\"config\"][\"organization_description\"] = description\n end\n domain = get_argument_value(\"org_domain\", false, nil)\n unless domain.nil?\n @config[\"config\"][\"organization_domain\"] = domain\n end\n contact_description = get_argument_value(\"contact_desc\", false, nil)\n unless contact_description.nil?\n @config[\"config\"][\"contact\"][\"description\"] = contact_description\n end\n email = get_argument_value(\"org_email\", false, nil)\n unless email.nil?\n @config[\"config\"][\"contact\"][\"email\"] = email\n end\n phone = get_argument_value(\"org_phone\", false, nil)\n unless phone.nil?\n @config[\"config\"][\"contact\"][\"phone\"] = phone\n end\n facebook = get_argument_value(\"org_facebook\", false, nil)\n unless facebook.nil?\n @config[\"config\"][\"contact\"][\"facebook\"] = facebook\n end\n twitter = get_argument_value(\"org_twitter\", false, nil)\n unless twitter.nil?\n @config[\"config\"][\"contact\"][\"twitter\"] = twitter\n end\n instagram = get_argument_value(\"org_instagram\", false, nil)\n unless instagram.nil?\n @config[\"config\"][\"contact\"][\"instagram\"] = instagram\n end\n website = get_argument_value(\"org_website\", false, nil)\n unless website.nil?\n @config[\"config\"][\"contact\"][\"website\"] = website\n end\n end\n success_prompt(\"Organization details configured.\")\nend",
"def greeting_a_person_new(name = 'friend')\n puts \"Hello, #{name}!\"\nend",
"def greeting(name)\n\t\tputs \" Hi there #{name}, how are you doing today?\"\n\tend",
"def configure; end",
"def greet\n\t\tputs \"Hi, my name is #{@name}\"\n\tend",
"def greeting \n\t\t\"Hi my name is #{@name}\"\n\tend",
"def configuring what\n puts \"Configuring: #{what}...\"\n end",
"def excited_greet(name)\nend",
"def greet_user email, options={}\n if options.empty?\n puts \"Hello #{email} welcome to my awesome application\"\n else\n puts \"Hello #{options[:name]}, how're you?\"\n puts \"I hear that #{options[:place]} is a beautiful place to live!\"\n end\nend",
"def alternative_config!\n JabberAdmin.configure do |conf|\n conf.username = 'admin@jabber.local'\n conf.password = 'defaultpw'\n conf.url = 'http://jabber.local/api'\n end\nend",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def config; end",
"def configure_jabber!( options )\n unless @connection = options.delete(:connection)\n self.class.jabber_id = options.delete(:jabber_id)\n self.class.password = options.delete(:password)\n self.class.resource = options.delete(:resource) || 'ruote'\n self.class.contacts = options.delete(:contacts) || []\n end\n end",
"def greeting(name=\"rubyist\")\n \"Welcome, #{name}! Ready to code?\"\nend",
"def greeting\n\t\t#make a greeting for both student and teacher\n\t\tputs \"Hi, my name is #{@name}!\"\n\tend",
"def quickstart\n if File.exist?(config_file)\n puts \"config file already exists: #{config_file}\"\n return\n end\n\n cli = HighLine.new\n nick = cli.ask(\"Username:\")\n file = cli.ask(\"Full local path to twtxt file:\")\n url = cli.ask(\"URL where txtxt will be published:\")\n open(config_file, 'w') do |f|\n f.puts \"[twtxt]\"\n f.puts \"nick = #{nick}\"\n f.puts \"twturl = #{url}\"\n f.puts \"twtfile = #{file}\"\n f.puts \"#check_following = True\"\n f.puts \"#use_pager = False\"\n f.puts \"#limit_timeline = 20\"\n f.puts \"#sorting = descending\"\n f.puts \"#post_tweet_hook = \\\"scp tw.txt bob@example.com:~/public_html/twtxt.txt\\\"\"\n end\n puts \"example config written to #{config_file}\"\nend",
"def initialize(name, age: nil, occupation: nil, hobby: nil, birthplace: \"Sleepy Creek\")\n\t\tself.name = name\n\t\tself.age = age\n\t\tself.occupation = occupation\n\t\tself.hobby = hobby\n\t\tself.birthplace = birthplace\n\tend",
"def greeting(name)\n puts \"Hello #{name}\"\n end",
"def greeting_programmer(name,language = \"Ruby\")\n puts \"Hi #{name} I heard you are good with #{language}\"\nend",
"def say_hi(\n name,# String\n greeting = \"hi\"# please\n )\nend",
"def say_hello (name= \"Ruby Programmer\")\n\n\tputs \"Hello #{name}!\"\nend",
"def more_like_this_config \n blacklight_config.more_like_this || {}\n end",
"def greeting(name)\n\tputs \"Hello \" + name + \". Have a nice day!\"\nend",
"def initialize(name, age: , occupation:, hobby: nil, birthplace: \"Sleepy Creek\")\n\t\tself.name = name\n\t\tself.age = age\n\t\tself.occupation = occupation\n\t\tself.hobby = hobby\n\t\tself.birthplace = birthplace\n\tend",
"def configure\n end",
"def welcome(greeting, options={})\n name = options[:name] || 'friend'\n punct = options[:punctuation] || '!'\n greeting + ' ' + name + punct\nend",
"def initialize(name, age:, occupation:, hobby: nil, birthplace: \"Sleepy Creek\")\n self.name = name\n self.age = age\n self.occupation = occupation\n self.hobby = hobby\n self.birthplace = birthplace\n end",
"def name=(value); configuration.name = value; end",
"def initialize(name, happiness=8, hygiene=8)\n #I initialize name, happiness and hygiene = 8 because they should start with 8 points each.\n @name = name\n @bank_account = 25\n @happiness = happiness\n @hygiene = hygiene\n end",
"def greeting\n puts \"Hi my name is #{@name}\"\n end",
"def initialize()\n @conf ||= []\n @proxy_type = \"defaults\"\n @conf.push(\" \" + \"#{@proxy_type} \" + \"\\n\")\n @name_index = @conf.index(\" \" + \"#{@proxy_type} \" + \"\\n\")\n end",
"def greet(greeting=\"Hello\")\n\tgreeting\nend",
"def greet(greeting=\"Hello\")\n\tgreeting\nend",
"def main(args)\n name = args['name'] || 'stranger'\n greeting = \"Hello #{name}\"\n puts(greeting)\n { greeting: greeting }\nend",
"def say_hello(name= \"Ruby Programmer\")\n puts \"Hello #{name}!\"\n\nend",
"def configurations; end",
"def greeting(name = \"friend\")\n \"Hello #{name}.\"\nend",
"def greet\n puts \"Hello, #{@name}!\"\n end",
"def greeting(name = 'neighbor')\n puts \"Hello, #{name}!\"\nend",
"def greet(greeting=\"Hello\", name=\"World\")\n puts \"#{greeting}, #{name}\"\nend",
"def config\n\n end",
"def hubot_options\n {\n :adapter => 'irc',\n :name => 'henshall',\n :repo => 'https://github.com/matthutchinson/henshall.git',\n :campfire_account => '',\n :campfire_rooms => '',\n :campfire_token => '',\n :irc_server => 'irc.perl.org',\n :irc_rooms => '#henshall'\n }\nend",
"def greeting\n puts \"Hi, my name is #{@name}.\"\n end",
"def configuration; end",
"def configuration; end",
"def configuration; end",
"def configuration; end",
"def configuration; end",
"def greeting(name)\n\t\"Hello, #{name}\"\nend",
"def declare_configuration_options\n ws.config.declare \"daemon_polling_period\", \"string\",\n default: \"60\",\n doc: \"Enter the github polling period\"\n\n ws.config.declare \"daemon_buildbot_host\", \"string\",\n default: \"localhost\",\n doc: \"Enter builbot host/ip\"\n\n ws.config.declare \"daemon_buildbot_port\", \"string\",\n default: \"8010\",\n doc: \"Enter buildbot http port\"\n\n ws.config.declare \"daemon_project\", \"string\",\n default: File.basename(ws.root_dir),\n doc: \"Enter the project name\"\n\n ws.config.declare \"daemon_max_age\", \"string\",\n default: \"120\",\n doc: \"Enter events and pull requests max age\"\n end",
"def greet\n puts '------------------------'\n puts \"Greetings to you #{@name}\"\n end",
"def greeting(name='Seth')\r\n\tputs 'hello '+name\r\nend",
"def initialize(gender,ethnicity,nickname)\n @age = rand(1..140)\n @gender = gender # Takes value at initialiation\n @ethnicity = ethnicity\n @nickname = nickname\n @reindeer_ranking = [\"Rudolph\", \"Dasher\", \"Dancer\", \"Prancer\", \"Vixen\", \"Comet\", \"Cupid\", \"Donner\", \"Blitzen\"]\n puts \"Initializing Santa instance...\"\n end",
"def greet(greeting=\"Hello\")\n\tputs greeting\nend",
"def initialize(name)\n @name = name\n @bank_account = 25\n @happiness = 8\n @hygiene = 8\n # Your end here should go to the left to be flush with your def. \n # Also, check the setting in your text editor to make sure you tab using 2 spaces, instead of 4. Ruby style only uses 2\n end",
"def greeting(name, options = {})\n if options.empty?\n puts \"Hi, my name is #{name}\"\n else\n puts \"Hi, my name is #{name} and I'm #{options[:age]} yes olds and I live in #{options[:city]}.\"\n end\nend",
"def greeting(name, options = {})\n if options.empty?\n puts \"Hi, my name is #{name}\"\n else\n puts \"Hi, my name is #{name} and I'm #{options[:age]}\" +\n \" years old and I live in #{options[:city]}.\"\n end\nend",
"def sayHi\n\t\tputs \"hello, my name is #{@name}\"\n\tend",
"def greeting(name)\n\tputs \"Hello, \" + name + \". How are you doing?\"\nend",
"def get_greetings(name) # no needs parenthesis (please dont put comments on same line as def, just this one :))\n \"Hello #{name}\"\nend",
"def greeting(name, options ={})\n if options.empty?\n puts \"Hi, my name is #{name}\"\n else\n puts \"Hi, my name is #{name} and I'm #{options[:age]}\" +\n \" years old and I live in #{options[:city]}.\"\n end\nend",
"def about\n\t\tputs \"Your gender is #{@gender}!\"\n\t\tputs \"Your ethnicity is #{@ethnicity}!\"\n\t\tputs \"Here is the #{@reindeer_ranking}!\"\n\t\tputs \"Santa is #{age} year(s) old!\"\n\tend",
"def sayhello(name, last_name='Rojas')#al hacer parametro=______ es un parametro por defecto, si no se especifica luego linea 6, me lo auto completa\n horoscope = 'capricornio'\n \"Hola #{name.capitalize} #{last_name.capitalize}. Pura Vida! #{horoscope}\" #notar que las interpolaciones estan separadas!!\nend",
"def greet(person_1=\"default\", person_2)\n p person_1 + \" and \" + person_2\nend",
"def initialize(name)\n @name = name\n @band = [ ]\n puts \"Great, I love the name #{name}!\"\n\n # genre_options array\n @genre_options = [ 'blues',\n 'punk',\n 'folk',\n 'jazz',\n 'indie',\n 'rock',\n 'pop',\n 'reggae',\n 'hip hop',\n 'baroque pop'\n ]\n\n # hometown_options array\n @hometown_options = [ \n 'New York',\n 'Chicago',\n 'San Francisco',\n 'Los Angeles',\n 'Seattle',\n 'Montreal',\n 'London',\n 'Paris',\n 'Berlin'\n ]\n\n # member_names array using name generator\n @musicians = [\n 'Chikere Marchand',\n 'Widsom Nelson', \n 'Darian Sachs', \n 'Brett Cinege',\n 'Yi Adamson',\n 'Vaska Brassington',\n 'Rain Bolton',\n 'Ratna Klimek',\n 'Lou Lyon',\n 'Isabel Favre',\n 'Lydie Berger',\n 'Marjolaine Gagnon',\n 'Lambert Lachapelle',\n 'Adrianna Huff',\n 'Cherie Perreault',\n 'Parris Lowry',\n 'Inga McCleary',\n 'Alyse Michaels',\n 'Della Mac Alastair',\n 'Cait Oliverson',\n 'Terra Hawk',\n 'Oswin Valentini',\n \"Isabelle Akerman\",\n \"Braden Paul\",\n 'Anona Dwight',\n 'Brighid Blake',\n 'Gauthier McGuinness'\n ]\n end",
"def initialize(name) #gender, ethnicity)\n\t\tputs \"Initializing Santa instance ....\"\n\t\t@name = name \n\t\t@location = \"the North Pole\"\n\t\t@gender = gender \n\t\t@ethnicity = ethnicity \n\t\t#@drink = drink\n\t\t# age, which is not passed in on initialization and defaults to 0\n\t\t@age = 0\n\t\t@reindeer = reindeer = [\"Rudolph\", \"Dasher\", \"Dancer\", \"Prancer\", \"Vixen\", \"Comet\", \"Cupid\", \"Donner\", \"Blitzen\"]\n\tend",
"def hello_house\n\t\tputs 'Hello from #{@name}.'\n\tend",
"def initialize(opts = {})\n\n # Defaults\n path = File.expand_path(\".\").to_s\n nick = opts[:nick] || config[:nick] || \"kirby-dev\"\n\n @config ||= {\n :svns => \"#{path}/#{nick}.svns\",\n :atoms => \"#{path}/#{nick}.atoms\",\n :pidfile => \"#{path}/#{nick}.pid\",\n :nick => nick,\n :channel => 'kirby-dev',\n :server => \"irc.freenode.org\",\n :delicious_user => nil,\n :delicious_pass => nil,\n :silent => false,\n :log => false,\n :logfile => \"#{path}/#{nick}.log\",\n :time_format => '%Y/%m/%d %H:%M:%S',\n :debug => false\n }\n \n # Nicely merge current options\n opts.each do |key, value|\n config[key] = value if value\n end\n end",
"def greeting(name: \"programmer\", language: \"ruby\") \n puts \"hello #{name}! We heard you love the #{language} program.\"\nend",
"def generate_config\n # define email\n puts \"enter the email you use to log into Harvest:\"\n email = gets\n # define password\n puts \"enter the password for this Harvest account:\"\n password = gets\n # define subdomain\n puts \"enter the subdomain for your Harvest account:\"\n subdomain = gets\n\nstr = <<EOS\nclass HarvestConfig\ndef self.attrs(overwrite = {})\n{\n :email => \"#{email.chomp!}\", \n :password => \"#{password.chomp!}\", \n :subdomain => \"#{subdomain.chomp!}\",\n :has_ssl => false,\n :user_agent => \"Ruby/HarvestThings\"\n}.merge(overwrite)\nend\nend\nEOS\n \n File.open(CONFIG_PATH, 'w') {|f| f.write(str) }\n end",
"def initialize(name)\n @name = name\n @bank_account = 25\n @happiness = 8\n @hygiene = 8\n\n\n end",
"def comment_config(name, options = {})\n # Set the message to be shown in logs\n log :comment, name\n\n file = File.join(Origen.root, 'config', 'application.rb')\n comment_lines(file, /^\\s*config.#{name}\\s*=.*\\n/)\n end",
"def say_hello(name = \"Ruby Programmer\")\n puts \"Hello #{name}!\"\nend",
"def say_hello(name = \"Ruby Programmer\")\n puts \"Hello #{name}!\"\nend",
"def say_hello(name = \"Ruby Programmer\")\n puts \"Hello #{name}!\"\nend",
"def say_hello(name = \"Ruby Programmer\")\n puts \"Hello #{name}!\"\nend",
"def say_hello(name = \"Ruby Programmer\")\n puts \"Hello #{name}!\"\nend",
"def initialize(name, attitude, age)\n puts \"One more #{Barrista} has joined us! Welcome #{name} (they are super #{attitude}), age #{age}.\"\n @name = name\n @attitude = attitude\n @age = age\n end"
] |
[
"0.6597587",
"0.62525284",
"0.6174202",
"0.60638344",
"0.5969972",
"0.595579",
"0.5915428",
"0.5845206",
"0.5796624",
"0.5772162",
"0.57536775",
"0.57479936",
"0.5696726",
"0.56653917",
"0.5648837",
"0.5621836",
"0.56044626",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.5585927",
"0.55657125",
"0.5548189",
"0.55090725",
"0.54969007",
"0.5452644",
"0.5448899",
"0.5420002",
"0.54154134",
"0.5409791",
"0.5409744",
"0.5402927",
"0.5402053",
"0.5396731",
"0.5394965",
"0.5389249",
"0.5387378",
"0.5386312",
"0.538289",
"0.53802574",
"0.53743744",
"0.53743744",
"0.53705156",
"0.53535885",
"0.5350769",
"0.5348465",
"0.5346763",
"0.53457254",
"0.53434956",
"0.5343399",
"0.53425014",
"0.5338146",
"0.5329303",
"0.5329303",
"0.5329303",
"0.5329303",
"0.5329303",
"0.5312809",
"0.5312232",
"0.53061193",
"0.5303044",
"0.5296876",
"0.52963793",
"0.52962655",
"0.5292275",
"0.528789",
"0.52801836",
"0.5280182",
"0.52792853",
"0.5274496",
"0.52743053",
"0.52726835",
"0.52690977",
"0.5263502",
"0.52568704",
"0.5249248",
"0.524432",
"0.5243814",
"0.52435625",
"0.5228148",
"0.52268356",
"0.5224418",
"0.5224418",
"0.5224418",
"0.5224418",
"0.5224418",
"0.5223971"
] |
0.0
|
-1
|
Returns an empty or existing array of abilities
|
def abilities
@abilities ||= {}
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def abilities_to_register\n []\n end",
"def abilities_to_register\n []\n end",
"def abilities\n (read_attribute(:abilities) || '').split(' ')\n end",
"def abilities\n @abilities ||= Six.new\n end",
"def abilities\n get('/ability/')\n end",
"def activated_abilities\n activated = abilities.select{|ability| ability.activated?}\n \n # Add the item abilities\n return activated + item_actions\n end",
"def facilities\n [self]\n end",
"def facilities\n [self]\n end",
"def index\n @abilities = Ability.all\n end",
"def get_catagories_for_mission\r\n catagories = []\r\n\r\n unlock_missions << self.mission if self.mission\r\n unlock_missions.concat(Mission.find_all_with_tag(self.tag)) if self.tag\r\n \r\n return catagories\r\n end",
"def room_amenity_list\n return [] if @raw_data[:RoomAmenityList].nil?\n if @raw_data[:RoomAmenityList].is_a?(Array)\n @raw_data[:RoomAmenityList]\n else\n [@raw_data[:RoomAmenityList]]\n end\n end",
"def ordered_abilities\n ability_names.sort\n end",
"def accountability_objects\n case count_method_for_accountability.to_sym\n when :awardees then awardees\n when :presenters then presenters\n when :complete then complete\n else []\n end\n end",
"def available_contract_missions\n Institution.all.map do |i|\n i.available_missions\n end.flatten\n end",
"def available_missions\n budget_missions - contracts.independent.includes(:mission).inject([]) do |m, c|\n (c.mission.repeatable? or c.status.to_sym == :failed)? m : m.push(c.mission)\n end.flatten\n end",
"def amenities\n %w(Bathroom Televison Towels)\n end",
"def build_defend_facilities(ship)\n array = []\n ship.facility_instances.each do |f|\n array << f\n end\n return array\n end",
"def items\n @items ||= menu_items.map{|i| Nyavi::Item.new(i, self)}.select(&:allowed?)\n end",
"def get_availabilities\n #retrieve all availability\n self.therapist_availability.collect{ |availability| availability_start_end_datetime(availability.get_occurrences, availability) }.flatten\n end",
"def available_go_cabs\n arr = []\n @go_cabs.select { |cab| arr << cab if (cab.available == true) }\n return arr\n end",
"def enabled_accounts\n return [] if self.accounts.nil?\n self.accounts.reject{|a|!a['enabled']}.map{|a|PadmaAccount.new(a)}\n end",
"def available_missions\n MissionCategory.where(\"minimum_balance <= ?\", [balance]).all.map do |c|\n c.missions.all\n end.flatten\n end",
"def skillsNeeded\n\t\t[]\n\tend",
"def filtered_abuses\n [AbuseType::OTHER]\n end",
"def taken_menu_items\n menu_items.map {|menu_item| menu_item.id if menu_item.dish_assignment}.compact\n end",
"def get_facilities(location)\n facilities = []\n location.location_facilities.each do |fac|\n facilities << fac.facility.name\n end\n\n facilities\n end",
"def get_missions_in_cat\r\n missions = []\r\n \r\n return missions\r\n end",
"def airports_out_of_region\n return Array.new\n end",
"def reset_abilities\n @capabilities.each do |cap|\n cant_do cap\n end\n end",
"def roles\n # we can't use abilities as those are not defined when creating a new operator that is not yet saved\n #result = abilities.collect(&:name)\n authorizations.collect{|auth| auth.ability.try(:name)}\n end",
"def roles\n # we can't use abilities as those are not defined when creating a new operator that is not yet saved\n #result = abilities.collect(&:name)\n authorizations.collect{|auth| auth.ability.try(:name)}\n end",
"def list_allowable(classification)\n return CLASSIFICATIONS unless CLASSIFICATIONS.include?(classification)\n CLASSIFICATIONS[0..CLASSIFICATIONS.index(classification)]\n end",
"def filtered_abuses\n AbuseType.values - [AbuseType::OTHER]\n end",
"def selectable_access_types\n [['Unrestricted Access', 'open'], ['Controlled Access', 'restricted'], ['Other', 'closed']]\n end",
"def power_ups\n @power_ups.map {|pup| Equip_Abilities.new(pup[0], pup[1], pup[2])}\n end",
"def initialize(abilities)\n @abilities = abilities\n end",
"def get_facilities\n list = organizations.map { |org| org.resource.identifier.last.value }\n facilities_ids = list.join(',')\n\n facilities_request.get(facilities_ids)\n end",
"def accessible_agencies\n Agency.accessible_by(Ability.new(self))\n end",
"def assigned_roles\n to_array_if_not(self.roles)\n end",
"def assignable_specialties\n\t\t(Specialty.predefined + specialties).sort_by(&:lower_case_name).uniq\n\tend",
"def accessible_roles\n @accessible_roles = Role.accessible_by(current_ability)\n end",
"def busy_go_cabs\n arr = []\n @go_cabs.select { |cab| arr << cab if (cab.available == false) }\n return arr\n end",
"def flyable_aircraft_types\n licensed_aircraft_type_ids = self.licenses.find(:all, :select => 'DISTINCT aircraft_type_id').collect { |r| r.aircraft_type_id }\n return AircraftType.find(:all, :conditions => ['id IN (?)', licensed_aircraft_type_ids]) || []\n end",
"def airports_normal\n return Array.new\n end",
"def current_astronauts\n missions.map {|mission| mission.astronaut}.uniq\n \n end",
"def skills_guard\n result = []\n states.each do |state|\n next unless state.skill_guard > 0\n result << [$data_skills[state.skill_guard], state.sg_range]\n end\n return result.uniq\n end",
"def skills\n\t\t[]\n\tend",
"def ability_names(pokemon)\n\t\tability_names = []\n\t\tpokemon[\"abilities\"].each do |i|\n\t\t\tability_names.push(i[\"ability\"][\"name\"])\n\t\tend\n\t\treturn ability_names\n\tend",
"def map(olympians)\n only_athletes = []\n for athlete in olympians\n if athlete[:event] == \"Atheletics\"\n only_athletes.push(athlete)\n end\nend\nreturn only_athletes\nend",
"def ways \n return [] \n end",
"def get_valid_items\n list = []\n @items.each do |id, number|\n item = $data_items[id]\n list << item if item.for_friend? || item.for_opponent?\n end\n return list\n end",
"def visit_attendance_options_array\n\t\t(visit_attendance_option_list + [\"Attended\"]).uniq\n\tend",
"def accessible_roles\n @accessible_roles = Level.accessible_by(current_ability, :read)\n end",
"def available_improvements\n availables = playbook.improvements.where.not(id: improvements.select(:id))\n unless Improvement.advanced_eligible?(self)\n availables = availables.not_advanced\n end\n availables\n end",
"def set_facilities\n if user_signed_in?\n if current_user.role == \"site_admin\"\n @userfacilities = Facility.all\n else\n @userfacilities = current_user.facility_relationships.includes(:facility_roles).where.not(facility_roles: {name: 'climber'}).all\n end\n end\n end",
"def accessible_roles\n @accessible_roles = Role.accessible_by(current_ability,:read)\n end",
"def accessible_roles\n @accessible_roles = Role.accessible_by(current_ability,:read)\n end",
"def accessible_roles\n @accessible_roles = Role.accessible_by(current_ability,:read)\n end",
"def accessible_roles\n @accessible_roles = Role.accessible_by(current_ability,:read)\n end",
"def accessible_roles\n @accessible_roles = Role.accessible_by(current_ability,:read)\n end",
"def list_ability(pk)\n puts \"\"\n puts \"Abilities:\"\n puts \"\"\n puts pk.abilities\n puts \"\"\n end",
"def unowned_purchasable_companies(_entity)\n []\n end",
"def lesson_plan_item_actable_names\n []\n end",
"def all_permissions\n return permissions unless role\n (permissions + role.permissions).uniq\n end",
"def gated_discovery_filters(permission_types = discovery_permissions, ability = current_ability)\n return [] if ability.current_user.administrator?\n super\n end",
"def allowed?(*abilities)\n abilities.all? { |a| runner(a).pass? }\n end",
"def get_unfiltered_suggestions\n map1 = Map.find_near_dificulty current_user.skill_mean, :easy\n map2 = Map.find_near_dificulty current_user.skill_mean, :medium, exclude: [map1]\n map3 = Map.find_near_dificulty current_user.skill_mean, :hard, exclude: [map1, map2]\n maps = [map1, map2, map3].compact\n maps.empty? ? nil : maps\n end",
"def merge_abilities\n current_ability.merge(Trough::Ability.new(current_user))\n end",
"def index\n @alloweds = Allowed.all\n end",
"def eligible_appeals\n active_fully_compensation_appeals.select(&:eligible_for_ramp?)\n end",
"def achievements\n return unless public?\n\n if @achievements.nil?\n @achievements = Array.new\n @xml_data.elements.each('achievements/achievement') do |achievement_data|\n @achievements << GameAchievement.new(@steam_id64, @app_id, achievement_data)\n end\n\n @achievements_done = @achievements.reject{ |a| !a.unlocked? }.size\n end\n\n @achievements\n end",
"def collect_anniversary_roles\n role_names = [\"Company Admin\", \"Executive\"]\n roles = []\n role_names.each do |role_name|\n roles << Role.find_by_long_name(role_name)\n end\n return roles\n end",
"def actable_hash_data(actable_name)\n case actable_name\n when Course::Assessment.name\n [actable_name, settings_interfaces_hash['course_assessments_component'].disabled_tab_ids_for_lesson_plan]\n when Course::Survey.name\n [actable_name, nil] if settings_interfaces_hash['course_survey_component'].showable_in_lesson_plan?\n when Course::Video.name\n [actable_name, nil] if settings_interfaces_hash['course_videos_component'].showable_in_lesson_plan?\n when Course::LessonPlan::Event.name\n [actable_name, nil]\n when Course::LessonPlan::Milestone.name\n [actable_name, nil]\n end\n end",
"def enable_when(abilities, rule)\n abilities.each { |a| own_ability_map.enable(a, rule) }\n end",
"def no_admin_set_abilities\n cannot [:edit, :create, :delete], Hydra::Admin::Collection\n end",
"def disallowed?(*abilities)\n abilities.all? { |a| !runner(a).pass? }\n end",
"def approvable_users\n @approvable_users ||= (controllable_users + editable_request_applicants + controllable_users.map{|uu|uu.editable_request_applicants}).flatten.uniq\n end",
"def index\n @room_facilities = RoomFacility.all\n end",
"def filter(items)\r\n\tnew_items = Array.new\r\n\titems.each { |item| new_items.push(item) unless should_ban(item) }\r\n\tnew_items\r\nend",
"def index\n @habilities = Hability.all\n end",
"def allowed_category_ids\n @allowed_category_ids ||=\n begin\n unrestricted = Category.where(read_restricted: false).pluck(:id)\n unrestricted.concat(secure_category_ids)\n end\n end",
"def unique_awards\n awards.uniq\n end",
"def facility_account_types\n @facility_account_types ||= []\n end",
"def available_interactions(_entity, _battle = nil)\n []\n end",
"def index\n @facilities = Role.find(current_user.current_role).facilities\n end",
"def list_items_inactive\r\n return_list = Array.new\r\n for s in self.item_list\r\n if !s.is_active?\r\n return_list.push(s)\r\n end\r\n end\r\n return return_list\r\n end",
"def list_items_inactive\r\n return_list = Array.new\r\n for s in self.item_list\r\n if !s.is_active?\r\n return_list.push(s)\r\n end\r\n end\r\n return return_list\r\n end",
"def college_application_choice_options_array\n return %w[Reach Solid Safety] if college_application_choice_options.blank?\n college_application_choice_options.try(:split, \"\\n\").try(:collect, &:strip).to_a\n end",
"def test_emptyArmor\n f = ArmorFilter.new()\n new_list = [].find_all{|x| f.apply(x)}\n return new_list.size == 0\n end",
"def active_difficulties(*values)\n if values.include? :none\n @difficulties = []\n else\n # Change active difficulties to what the user supplies, but only when they supply a difficulty we already know about\n @difficulties = values.reject { |v| not @difficulties.include? v }\n end\n end",
"def accessible_roles\n @accessible_roles = Role.accessible_by(current_ability, :read)\n end",
"def accessible_roles\n @accessible_roles = Role.accessible_by(current_ability, :read)\n end",
"def getActiveQuests\n active = []\n $PokemonGlobal.quests.active_quests.each do |s|\n active.push(s.id)\n end\n return active\nend",
"def index\n authorize! :read, Guara::Ability\n @modules = SystemModule.all\n @abilities = SystemAbility.all\n end",
"def gated_discovery_filters(permission_types = discovery_permissions, ability = current_ability)\n return [] if ability.admin?\n super\n end",
"def index\n #you dont want to set the permissions for Super Admin.\n @roles = Role.all.keep_if{|i| i.name != \"Super Admin\"}\n end",
"def as_selectable_array\n all.inject([]) { |h,t| h << [t.name, t.key] }\n end",
"def available_rooms\n available_rooms = reservations.select do |reservation|\n reservation.status == :HOLD\n end\n \n return available_rooms\n end",
"def accountable_organisms_with_room\n rooms.select {|r| r.look_for { r.organism.accountable? } }\n end",
"def index\n @doctor_unavailabilities = current_doctor.doctor_unavailabilities.all\n end"
] |
[
"0.754501",
"0.7383248",
"0.7233026",
"0.71824116",
"0.6516052",
"0.6487794",
"0.6312706",
"0.6312706",
"0.6077586",
"0.59423876",
"0.593129",
"0.59195054",
"0.5914095",
"0.5863681",
"0.58461815",
"0.5838893",
"0.57735115",
"0.57509035",
"0.5732901",
"0.5720581",
"0.5701555",
"0.5692709",
"0.56906575",
"0.5684681",
"0.563577",
"0.56310403",
"0.559044",
"0.5583573",
"0.556951",
"0.5564154",
"0.5564154",
"0.55633926",
"0.55477756",
"0.5537381",
"0.552967",
"0.5510678",
"0.5501803",
"0.5493576",
"0.54567677",
"0.5453519",
"0.5439899",
"0.5421533",
"0.54208165",
"0.5412317",
"0.53968143",
"0.53924966",
"0.5383385",
"0.5368506",
"0.53280336",
"0.5315102",
"0.53083146",
"0.53042877",
"0.530252",
"0.53006387",
"0.52992684",
"0.5296806",
"0.5296806",
"0.5296806",
"0.5296806",
"0.52963203",
"0.5284791",
"0.52712274",
"0.5268389",
"0.52638584",
"0.5255067",
"0.52514106",
"0.5248303",
"0.52322465",
"0.5219546",
"0.5214798",
"0.52110225",
"0.5208759",
"0.52045715",
"0.5203715",
"0.51952714",
"0.51843077",
"0.51825655",
"0.5181928",
"0.5180403",
"0.517743",
"0.5176785",
"0.5172595",
"0.5168125",
"0.51663136",
"0.51657623",
"0.5163247",
"0.5163247",
"0.51607084",
"0.5156792",
"0.5155288",
"0.5151876",
"0.5151876",
"0.514885",
"0.5140151",
"0.5138986",
"0.5134257",
"0.51319444",
"0.5124794",
"0.51184076",
"0.5107991"
] |
0.7582291
|
0
|
Registers a new Girlfriend ability Girlfriend.register_ability :talk do |girl| Girlfriend::Ability::Talk.new(girl) end
|
def register_ability(name, &block)
abilities[name] = block
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def initialize ability\n @ability = ability\n end",
"def add_ability(func_name, timeout=nil, &block)\n @abilities[func_name] = Ability.new(func_name, block, timeout)\n @connection_pool.with_all_connections do |connection|\n announce_ability(func_name, timeout, connection)\n end\n end",
"def add_ai_player\n @bots << setup_player(:bot => true)\n end",
"def ability\n @ability ||= Ability.new(self)\n end",
"def ability\n @ability ||= Ability.new(self)\n end",
"def ability\n @ability ||= Ability.new(self)\n end",
"def ability\n @ability ||= Ability.new(self)\n end",
"def ability\n @ability ||= Ability.new(self)\n end",
"def initialize ability\n @ability = ability\n end",
"def ability\n @ability ||= ::Ability.new(self)\n end",
"def add(name, weapon)\n gladiators.push(Gladiator.new(name, weapon)) if (gladiators.size < 2)\n end",
"def adventuring() skill(:adventuring) end",
"def allowTalkToSelf()\n banner(\"Allow Agents to mumble\")\n @mumbleFlag = true\n end",
"def hook_thyself\n me = self;\n\n # Show blacklist\n register_command(:omeg_blacklist_show, /^[Oo]megleBlacklist$/, /channel/){\n me.report_blacklist(bot, channel)\n }\n \n # Toggle use of blacklist for a user \n register_command(:omeg_blacklist, /^[Tt]oggleMe$/, /channel/){\n me.toggle_blacklist(bot, channel, nick)\n }\n\n # Toggle use of nick template\n register_command(:omeg_toggle, /^[Tt]oggleNick$/, /channel/){\n me.toggle_nick(bot, channel)\n }\n\n # Connect to a single stranger with <nickname> support\n register_command(:omeg_connect, /^[Oo]megle$/, /channel/){|*topics|\n me.ensure_not_blacklisted(channel, nick)\n me.summon_omegleite(bot, channel, topics)\n }\n \n # Connect to a single stranger with <nickname> support\n register_command(:omeg_ask, /^[Aa]skMe$/, /channel/){\n me.ensure_not_blacklisted(channel, nick)\n me.summon_omegleite(bot, channel, nil, true)\n }\n\n # Spy mode, ask a question and watch two people debate.\n register_command(:omeg_spy, /^[Aa]sk$/, /channel/){|*question|\n if(question.length < 0)\n bot.say(\"Please provide a question!\")\n else\n me.spy_mode(bot, channel, question.join(\" \"))\n end\n }\n\n end",
"def befriend new_friend\n run_callbacks :befriend do\n friendships.create friend: new_friend\n end\n end",
"def register(song_name)\n prior_play = @current_user.listens.select{|listen| listen.name == song_name}.first\n if prior_play\n @current_listen = prior_play\n @current_listen.plays += 1\n else\n @current_listen = Listen.new\n @current_listen.name = song_name\n @current_listen.plays = 1\n @current_user.listens << @current_listen\n end\n end",
"def register_player!(params)\n self.player = Player.new(params)\n self.roles << :player\n self.save\n self.player.save\n self.player\n end",
"def set_ability\n @current_ability ||= Ability.new(User.new)\n end",
"def ability\n @ability ||= Ability.new(current_user)\n end",
"def define_gender(playing_girl)\n @playing_girl = playing_girl\n $game_switches[Yuki::Sw::Gender] = playing_girl\n $game_variables[Yuki::Var::Player_ID] = id\n $game_actors[1].name = name\n end",
"def set_ability\n @ability = Ability.friendly.find(params[:id].titleize)\n end",
"def create\n @talk = Talk.new(params[:talk], :as => admin? ? :admin : :default)\n @talk.user = current_user\n\n respond_to do |format|\n if @talk.save()\n format.html { redirect_to my_profile_index_path, notice: 'Takk, ditt foredragsforslag er registrert.' }\n else\n format.html { render action: \"new\" }\n end\n end\n end",
"def act_as_mentioner\n include Mentioner\n end",
"def initialize\n register_script \"Leave messages for inactive users.\"\n\n register_event :PRIVMSG, :on_privmsg\n\n register_command \"tell\", :cmd_tell, 2, 0, nil, \"Have the bot tell the given user something the next time they speak. Parameters: nick message\"\nend",
"def give_bonus player\n player.add_weapon(Vibrant_Weapon.new(@window, player))\n end",
"def befriend! new_friend\n run_callbacks :befriend do\n friendships.create! friend: new_friend\n end\n end",
"def set_ability\n @ability = Ability.find(params[:id])\n end",
"def meow\n puts \"meow!\" #can meow\n end",
"def add_talk(talk)\n @talks.push(talk)\n end",
"def allow_registration(method); end",
"def register_battler(battler)\n if @unit_table[battler.hashid]\n debug_print \"Battler register failed: #{battler}\"\n return\n end\n @enemies << battler\n @action_battlers[battler.team_id] << battler\n @unit_table[battler.hashid] = battler\n SceneManager.scene.register_battle_unit(battler) if SceneManager.scene_is?(Scene_Map)\n end",
"def act_as_mentionee\n include Mentionee\n end",
"def ability_used(attack_type, mod_type)\n puts \"You used a #{attack_type} attack with a plus #{mod_type} increase!\"\nend",
"def registered_adult(user)\n # TENANT\n can :manage, Tenant do |t|\n t.organisers.include? user\n end\n\n can :read_reports, Tenant do |t|\n # TODO: put per tenant shit here (prob by checking tenant config)\n can? :manage, t\n end\n\n can :read_dashboard, Tenant do |t|\n # TODO: put per tenant shit here (prob by checking tenant config)\n can? :manage, t\n end\n\n can :create_tenanted_league, Tenant do |t|\n # TODO: put per tenant shit here (prob by checking tenant config)\n can? :manage, t\n end\n\n can :manage_leagues do |t|\n # TODO: put per tenant shit here (prob by checking tenant config)\n can? :manage, t\n end\n\n can :manage_teams, Tenant do |t|\n # TODO: put per tenant shit here (prob by checking tenant config)\n can? :manage, t\n end\n\n # LEAGUE\n can :manage, League do |l|\n l.has_organiser?(user) || can?(:manage_leagues, l.tenant)\n end\n \n # DIVISION\n can :manage, DivisionSeason do |div|\n can? :manage, div.league\n end\n\n can :read_unpublished, DivisionSeason do |div|\n can? :manage, div.league\n end\n\n can :add_team, DivisionSeason do |ds|\n ds.config.applications_open\n end\n\n # FIXTURE\n can :manage, Fixture do |fx|\n can? :manage, fx.division_season\n end\n\n # RESULT\n can :update, Result do |r|\n can? :manage, r.fixture\n end\n\n # POINTS\n can :update, Points do |p|\n can? :manage, p.fixture\n end\n\n can :update, User do |user_check|\n\n can_update = false\n\n if (user == user_check || can?(:act_on_behalf_of, user_check) || admin_of_users_league?(user, user_check))\n can_update = true\n\n elsif user_check.role?(RoleEnum::INVITED)\n #SR - there is a problem in that a user could be invited dto multiple teams and an organiser could update\n #their details and the update would be seen across all teams!\n can_update = (user_check.team_roles.map(&:obj_id) & user.teams_as_organiser_ids).count > 0\n end\n\n can_update\n end\n\n can :update, DemoUser do |user_check|\n user == user_check \n end \n\n # TEAM\n can :create, Team\n\n can :create_o2_touch_team, Team do |team|\n # true\n user.teams_as_organiser.select{|t| t.tenant_id == TenantEnum::O2_TOUCH_ID }.count > 0\n end\n\n can :create_mitoo_team, Team\n\n can :create_alien_team, Team do |team|\n false\n end\n\n can :create_soccer_sixes_team, Team do |team|\n false\n end\n\n can :update, Team do |team|\n team.has_organiser?(user)\n end\n\n # including creating events\n can :manage, Team do |team|\n # nil check, so we can chain the abilites together, without nil checks everywhere\n team != nil && (team.has_organiser?(user) || can?(:manage_teams, team.tenant))\n end\n\n can :manage_roster, Team do |team|\n # change LMR settings to use new config # need a better method name here...\n can?(:manage, team) || (team.league_managed_roster? && team.user_is_primary_league_admin?(user)) \n end\n\n can :add_follower, Team do |team|\n team.config.team_followable && team.has_associate?(user)\n end\n\n can :become_faft_organiser, Team do |team|\n team.faft_team? && team.organisers.count == 0 && team.has_follower?(user)\n end\n\n can :delete, PolyRole do |poly_role|\n if poly_role.obj.is_a? Team\n if poly_role.user_id == user.id\n poly_role.role_id == PolyRole::FOLLOWER\n else\n can? :manage_roster, poly_role.obj #team\n end\n else\n false\n end\n end\n\n can :create_message, Team do |team|\n team.has_active_member?(user)\n end\n\n can :view_public_profile, Team do |team|\n team.has_follower?(user)\n end\n\n # EVENT\n can :create, Event if user.teams_as_organiser.count > 0\n\n # nb. This ability duplicated (for app speed) in event_json_helper.rb, so make\n # any edits there aswell! TS.\n can :manage_event, Event do |event|\n # organiser, or registered team organiser\n if !event.fixture.nil?\n false #abitshit ie. won't work once fixtures are used outside of leagues. TS\n else\n event.user_id == user.id || can?(:manage, event.team)\n end\n end\n\n can :manage_event, DemoEvent do |event|\n # organiser, or registered team organiser\n event.user_id == user.id || can?(:manage, event.team)\n end\n \n can :send_invites, Event do |event|\n # registered event or team organiser\n event.user_id == user.id || can?(:manage, event.team)\n end\n \n can :create_message, Event do |event|\n # organiser, or registered player\n # TODO: generalise this set of perms (and refactor to check user has role on team)\n #event.team.has_associate?(user) &&\n (event.user_id == user.id || event.is_invited?(user) || user.child_invited_to?(event) || can?(:manage, event.team))\n end\n\n can :create_message, DivisionSeason do |div|\n # TODO: This is very slow\n div.league.has_organiser? user\n end\n\n # ACTIVITY ITEM COMMENTS AND LIKES\n can :comment, EventMessage do |message| \n # if this implementation changes then a test is required\n if message.messageable.is_a? Team \n team = message.messageable\n team.has_active_member?(user)\n elsif message.messageable.is_a? Event\n can? :create_message, message.messageable\n end \n end\n\n can :like, EventMessage do |message| \n # if this implementation changes then a test is required\n can? :comment, message\n end\n\n can :comment, EventResult do |event_result|\n # if this implementation changes then a test is required\n can? :create_message, event_result.event \n end\n can :like, EventResult do |event_result|\n # if this implementation changes then a test is required\n can? :create_message, event_result.event \n end\n\n #SR - NEED TO FIX ALL OF THIS\n can [:like, :comment], [InviteResponse, InviteReminder] do |obj|\n #obj.teamsheet_entry.event.team.has_active_member?(user)\n true\n end\n \n can [:like, :comment], Event do |event|\n #event.team.has_active_member?(user)\n true\n end\n\n can [:like, :comment], TeamsheetEntry do |tse|\n #tse.event.team.has_active_member?(user)\n true\n end\n\n can :destroy, ActivityItemLike do |like|\n user == like.user\n end\n\n can :update, ActivityItem do |ai|\n #Currently we can only update EventMessage items. \n #Premissions around ActivityItem objs are a bit tricky however for now\n #it makes sense to check if the current user can update the 'obj'.\n\n if ai.obj_type == EventMessage.name\n #SR We want to check that the user can manage a team but I am not going to implement,\n #this check until we have a nice way to extract this information. \n #I am currently checking in or manage team directly in the controller\n else\n false\n end\n end\n end",
"def register\n \n end",
"def custom_permissions\n can [:create], Account\n end",
"def custom_permissions\n can [:create], Account\n end",
"def ability_initialize(opts)\n ability = data.abilities\n if opts[:ability]\n @ability = opts[:ability]\n else\n ability_chance = rand(100)\n @ability = ability[@ability_index = ABILITY_CHANCES.find_index { |value| value > ability_chance }].to_i\n end\n @ability = GameData::Abilities.find_using_symbol(@ability) unless @ability.is_a?(Integer)\n @ability_current = @ability\n @ability_used = false\n end",
"def hook_thyself\n me = self\n\n register_command(:fortune, /^[Ff]ortune$/, /channel/){ \n me.fortune(bot)\n }\n\n register_command(:eight_ball, /^8(ball)?$/, /channel/){|*msg|\n me.eight_ball(bot, msg.join(\" \"))\n }\n end",
"def signup(gym, cost, lifter)\n membership = Membership.new(gym, cost)\n self.membership << gym\n end",
"def current_ability\n @current_ability ||= Ability.new(current_player)\n end",
"def create\n @character = Character.new(character_params)\n\n respond_to do |format|\n if @character.save\n Ability.all.each {|a|\n CharacterAbility.create(ability: a, character: @character, value: 10)\n }\n format.html { redirect_to @character, notice: 'Character was successfully created.' }\n format.json { render :show, status: :created, location: @character }\n else\n format.html { render :new }\n format.json { render json: @character.errors, status: :unprocessable_entity }\n end\n end\n end",
"def register_into(bot, send_as: :bots, starter: true)\n bot.use Peribot::GroupMe::ImagePostprocessor\n\n case send_as\n when :bots\n bot.use Peribot::GroupMe::BotFilter\n bot.use Peribot::GroupMe::BotSender\n when :user\n bot.use Peribot::GroupMe::UserSender\n bot.use Peribot::GroupMe::UserLikeSender\n end\n\n register_groupme_starter_for bot if starter\n end",
"def make_canable_able \n begin\n logger.debug \"make_canable_able: #{name}\"\n insert_into_model name do\n canable_include_txt\n end\n rescue\n say \"model #{name} does not exist. Please create it first before you can make it Canable:Able\", :red\n end\n end",
"def register\n end",
"def add_ai_player(type, user)\n @player = Player.new({:ai => type, :game_id => self.id, :user_id => user.id, :money => 100, :username => 'ai '+type.to_str, :location => self.get_empty_location(), :in_pot_hand => 0, :in_pot_current => 0})\n self.players << @player\n self.save\n end",
"def register\n raw \"PASS #{@config[:password]}\" if @config.key? :password\n raw \"CAP LS\" if defined? MODULE_LOADED_CLIENT_CAPABILITIES\n\n raw \"NICK #{@nick}\"\n raw \"USER #{@user} 0 0 :#{@realname}\"\n end",
"def enable_lessons_containing_me\n manage_lessons_containing_me(true)\n end",
"def current_ability\n @current_ability ||= Gesmew::Ability.new(try_gesmew_current_user)\n end",
"def register\n end",
"def register\n end",
"def register\n end",
"def add_module_irc_behavior(type)\n define_add_behaviour type\n define_del_behaviour type\n end",
"def permit(type,options={})\n raise NameError.new(\"duplicate ability definition\") if @ability.key? type\n ability_object = GraphQL::Authorization::AbilityType.new(type,nil,{})\n if options.key?(:except) && options.key?(:only)\n raise ArgumentError.new(\"you cannot specify white list and black list\")\n end\n if options[:except]\n ability_object.access(type.fields.keys.map(&:to_sym) - options[:except])\n elsif options[:only]\n ability_object.access(options[:only])\n end\n ability_object.execute options[:execute]\n if block_given?\n #note Proc.new creates a proc with the block given to the method\n ability_object.instance_eval(&Proc.new)\n end\n @ability[type] = ability_object\n end",
"def create\n @my_girlfriend = MyGirlfriend.new(my_girlfriend_params)\n @my_girlfriend.user_id = current_user.id\n respond_to do |format|\n if @my_girlfriend.save\n format.html { redirect_to @my_girlfriend, notice: 'My girlfriend was successfully created.' }\n format.json { render :show, status: :created, location: @my_girlfriend }\n else\n format.html { render :new }\n format.json { render json: @my_girlfriend.errors, status: :unprocessable_entity }\n end\n end\n end",
"def register\n @is_registered = true\n self\n end",
"def initialize(user)\n\n # We instantiate the user to User.new to avoid having user be nil if the user is not signed in - so methods can be called on it. We assume here that 'user' will be User.new if the user is not signed in.\n user ||= User.new\n\n # Gives superpowers to admin user by having the ability to manage all actions on all models\n # If a field is a boolean, Rails automatically creates a helper method with a question mark (alternatively, you can user user.admin, which references the value - true or false)\n can :manage, :all if user.admin?\n\n # Define alias_action instead of using :manage\n alias_action :create, :read, :update, :destroy, :to => :crud\n\n # Defining the ability to :manage (do anything) with a question\n can :crud, Question do |q|\n # This block returns true or false. This determines if the user is allowed to manage a question or not\n # user.persisted? ensures the user is actually logged in\n q.user == user && user.persisted?\n end\n\n can :crud, Answer do |a|\n # Both the author of the question and the author of the answer can CRUD an answer\n (a.question.user == user || a.user == user) && user.persisted?\n end\n\n can :like, Question do |q|\n q.user != user\n end\n\n can :destroy, Like do |l|\n l.user == user\n end\n\n # It is possible to define any action, i.e. can :edit / can :destroy ...etc\n\n # Define abilities for the passed in user here. For example:\n #\n # user ||= User.new # guest user (not logged in)\n # if user.admin?\n # can :manage, :all\n # else\n # can :read, :all\n # end\n #\n # The first argument to `can` is the action you are giving the user\n # permission to do.\n # If you pass :manage it will apply to every action. Other common actions\n # here are :read, :create, :update and :destroy.\n #\n # The second argument is the resource the user can perform the action on.\n # If you pass :all it will apply to every resource. Otherwise pass a Ruby\n # class of the resource.\n #\n # The third argument is an optional hash of conditions to further filter the\n # objects.\n # For example, here the user can only update published articles.\n #\n # can :update, Article, :published => true\n #\n # See the wiki for details:\n # https://github.com/CanCanCommunity/cancancan/wiki/Defining-Abilities\n end",
"def abilities_to_register\n []\n end",
"def give_bonus player\n player.add_1_life\n end",
"def register\n raise NotImprementedError\n end",
"def create\n @talk = Talk.new(talk_params)\n @talk.sender = current_user\n\n respond_to do |format|\n if @talk.save\n format.html { redirect_to talks_user_path(@talk.recepient) }\n format.json { render :show, status: :created, location: @talk }\n else\n format.html { render :new }\n format.json { render json: @talk.errors, status: :unprocessable_entity }\n end\n end\n end",
"def announce_ability(func_name, timeout, connection)\n cmd = timeout ? :can_do_timeout : :can_do\n arg = timeout ? \"#{func_name}\\0#{timeout.to_s}\" : func_name\n connection.send_update(Packet.pack_request(cmd, arg))\n logger.debug \"Announced ability #{func_name}\"\n end",
"def set_ability_from_name\n ability_string = name[/ \\d /]\n if ability_string\n self.ability = ability_string.to_i\n else\n self.ability = 0\n end\n end",
"def register(handler)\n conf = @config\n bot = self\n isaac = @bot\n\n @bot.register{|type, msg|\n begin\n $log.debug \"Received message: #{type} #{msg}\"\n handler.dispatch(type, msg, bot.clone_state(msg)) # TODO: send a binding?\n rescue Exception => e\n $log.warn e.to_s\n $log.debug e.backtrace.join(\"\\n\")\n end\n }\n end",
"def register(count, regex, reply)\n register_hook(\"autoreply_msg#{count}\".to_sym, lambda{|raw| raw.message =~ regex}, /channel/){\n bot.say( reply )\n }\n end",
"def initialize_cancan_ability\n ability_class_name = resource.namespace.cancan_ability_class\n\n if ability_class_name.is_a?(String)\n ability_class = ActiveSupport::Dependencies.constantize(ability_class_name)\n else\n ability_class = ability_class_name\n end\n\n ability_class.new(user)\n end",
"def call_friend(friend)\n self.happiness += 3\n friend.happiness += 3\n \"Hi #{friend.name}! It's #{self.name}. How are you?\"\n end",
"def create_listener\n return unless self.controller_name == \"registrations\"\n @listener = Listener.new\n @listener.save\n end",
"def register_victory(mode = :league)\n pokemon_array = []\n $actors.each { |pkm| pokemon_array << pkm.clone }\n victory = {\n mode: mode,\n team: pokemon_array,\n play_time: $pokemon_party.trainer.play_time_text,\n entry_date: Time.new\n }\n @player_victory << victory\n end",
"def yourself(stage_name, firstname, surname, quirk, special_talent)\n\n if check_if_exists?(stage_name)\n you = SpiceGirl.new(stage_name, firstname, surname, quirk, special_talent)\n append_member(you)\n else\n raise \"You already have a girl of that name\"\n end\n end",
"def talk\r\n puts \"Hi I'm #{@name}\"\r\n self\r\n end",
"def create\n @girlfriend = Girlfriend.new(girlfriend_params)\n\n respond_to do |format|\n if @girlfriend.save\n format.html { redirect_to @girlfriend, notice: 'Girlfriend was successfully created.' }\n format.json { render :show, status: :created, location: @girlfriend }\n else\n format.html { render :new }\n format.json { render json: @girlfriend.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_permission(permission) \n self.permissions << permission\n end",
"def introduce_the_game\n @irc_server.puts \"Welcome to hangman!\"\n @irc_server.puts \"To get started, enter a word to be guessed\"\n end",
"def add_like(like_name)\n UserLikeLinker.link_user_and_like(self, self.personality.get_new_like(like_name)) \n end",
"def call_friend(friend)\n self.happiness += 3\n friend.happiness += 3\n \"Hi #{friend.name}! It's #{self.name}. How are you?\"\n end",
"def call_friend(person)\n person.happiness += 3\n self.happiness += 3\n return \"Hi #{person.name}! It's #{self.name}. How are you?\"\n end",
"def abilities_to_register\n []\n end",
"def invite_people\n end",
"def registerHook\n if !session[:user_id]\n flash[:notice] = \"Need to login first\"\n redirect_to :action=> 'login'\n end\n\n url = params[:registerhook][\"url\"]\n token = params[:registerhook][\"token\"]\n\n #redirect_to :controller=>\"room\", :action=> 'registerHook' #, :params[:registerHook].url => url, :params[:registerHook].token=>token\n \n begin\n am = session[:am]\n acc = Account.find_by_username(session[:user_id])\n if(acc.nil?)\n flash[:notice] = \"Need to login first\"\n redirect_to :action=> 'login'\n return\n end\n am.keepalive(acc.username, acc.password)\n result = am.registerHook(url, token)\n flash[:result] = \"registerHook result success: \" + result\n redirect_to :action => 'accountManager'\n rescue Exception => msg\n flash[:notice] = msg\n end\n end",
"def can?(name)\n\t\t\tabilities.include? name\n\t\tend",
"def generate_responsibilities\n set_positions\n set_team_members\n create_responsibilities\n\n\n\n assign_responsibilities\n\n # assign_team_members\n end",
"def add_writer(arg)\n chg_permission(writers, arg, :add)\n end",
"def make_player_character\n cast player_class, name: 'yourself', synonyms: 'self myself you me', proper_named: true\n end",
"def current_ability\n @current_ability ||= Ability.new(current_usuario)\n end",
"def register\n\n\tend",
"def allow_registration method\n @register_semaphore.synchronize do\n @dynamic_capabilities.add method\n end\n end",
"def add_as_moderator\n api('room.add_moderator', :roomid => room.id, :section => room.section, :target_userid => id)\n true\n end",
"def add_custom_handlers\n # Set up hooks\n @irc.on_msg self.method(:_in_msg)\n @irc.on_act self.method(:_in_act)\n @irc.on_invite self.method(:_in_invited)\n @irc.on_kick self.method(:_in_kick)\n @irc.saying_join self.method(:_out_join)\n end",
"def register\r\n \r\n end",
"def singup (gym, cost)\n new_memebership = Membership.new(cost , self, gym)\n end",
"def register(nicknam, realname, passwd = nil, mode = 0)\n pass(passwd) if passwd\n nick(nicknam)\n user(nicknam, realname, mode)\n end",
"def current_ability\n @current_ability ||= Ability.new(current_user_efi, :efi)\n end",
"def set_my_girlfriend\n @my_girlfriend = MyGirlfriend.find(params[:id])\n end",
"def register_account\n profile = Profile.new(params[:profile])\n profile = update_profile_for_register_account(profile)\n if save_objeck(profile)\n if Notifier.trigger_register_thank_you(profile.id)\n profile.histories.create(:message => \"Register Thank You email sent\")\n end\n show_success(profile.class.to_s)\n set_session_user(profile.user)\n else\n profile = handle_profile_errors(profile)\n show_failure(profile)\n end\n end",
"def speak\n puts \"I'm a person\"\n end",
"def recruit_follower(follower)\n Bloodoath.new(self,follower)\n end",
"def create\n @chat_room = ChatRoom.new(chat_room_params)\n respond_to do |format|\n if @chat_room.save\n @chat_room.user_admit_room(current_user)\n format.html { redirect_to @chat_room, notice: 'Chat room was successfully created.' }\n else\n format.html { render :new }\n end\n end\n end",
"def register!\n @planet.next_raid_at += Cfg.raiding_delay_random\n @planet.raid_arg = generate_arg\n CallbackManager.register_or_update(\n @planet, CallbackManager::EVENT_RAID, @planet.next_raid_at\n )\n @planet.delayed_fire(@planet, EventBroker::CHANGED,\n EventBroker::REASON_OWNER_PROP_CHANGE)\n @planet.save!\n end",
"def create\n Guy.create(guy_params)\n redirect_to log_in_path\n end"
] |
[
"0.5804026",
"0.573823",
"0.57246786",
"0.5690421",
"0.5690421",
"0.5690421",
"0.5690421",
"0.5690421",
"0.56817305",
"0.56157243",
"0.56028426",
"0.5547905",
"0.5520074",
"0.54803413",
"0.5477103",
"0.5406545",
"0.534792",
"0.530494",
"0.52957565",
"0.52653575",
"0.52394325",
"0.52280015",
"0.5206682",
"0.51991695",
"0.51691437",
"0.5152444",
"0.51326686",
"0.5080167",
"0.50467193",
"0.50440645",
"0.503706",
"0.5007732",
"0.4999632",
"0.4980984",
"0.49717584",
"0.49550635",
"0.49550635",
"0.49349448",
"0.4931376",
"0.49293587",
"0.49271035",
"0.49159908",
"0.49075437",
"0.49021876",
"0.4894338",
"0.48888642",
"0.48822108",
"0.48779044",
"0.48639402",
"0.48627618",
"0.48627618",
"0.48627618",
"0.48575255",
"0.48550534",
"0.4854078",
"0.4849719",
"0.48430294",
"0.4841554",
"0.48408785",
"0.48322013",
"0.4812765",
"0.48097345",
"0.47997275",
"0.47912762",
"0.47835976",
"0.47829998",
"0.47828808",
"0.47765929",
"0.4776294",
"0.47760752",
"0.4775128",
"0.47706375",
"0.47579238",
"0.4750476",
"0.47447148",
"0.47444817",
"0.47430837",
"0.47409832",
"0.47402537",
"0.47271666",
"0.4723084",
"0.4722718",
"0.47137403",
"0.47080582",
"0.47064272",
"0.47045577",
"0.4698756",
"0.46965086",
"0.46933073",
"0.4690713",
"0.46719223",
"0.46710554",
"0.46689856",
"0.46665472",
"0.4663462",
"0.46618432",
"0.46530867",
"0.46511325",
"0.46487448",
"0.4645544"
] |
0.64486384
|
0
|
Returns TRUE if the given ability exists, otherwise FALSE
|
def can?(name)
abilities.include? name
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def ability?\n self.__ability.present?\n end",
"def has_achievement?(name)\n achievements.exists?(name: name)\n end",
"def exist?\n @access.exist?\n end",
"def exist?\n @access.exist?\n end",
"def _has_capability?(capability)\n allow = nil\n deny = nil\n\n roles.each do | role |\n case role.has_capability?(capability)\n when true\n allow = true\n else false\n deny = true\n end\n end\n\n=begin\n $stderr.puts \" User[#{self.name.inspect}]._has_capability?(#{capability.inspect})\"\n $stderr.puts \" allow = #{allow.inspect}\"\n $stderr.puts \" deny = #{deny.inspect}\"\n=end\n \n case\n when allow == true\n true\n when deny == true\n false\n else\n nil\n end\n end",
"def allowed?(*abilities)\n abilities.all? { |a| runner(a).pass? }\n end",
"def can?(action, object)\n method_eh = \"can_#{action}?\"\n abilities = resolve_object(object)\n _scope_method = scope_method(abilities, action)\n model_class = object.class\n\n if abilities.respond_to?(method_eh)\n abilities.send(method_eh, object, user)\n elsif _scope_method && object.id\n abilities.send(_scope_method, model_class, user).where(id: object.id).any?\n else\n false\n end\n end",
"def can?(key)\n resolved_permissions['permissions'].collect(&:key).include? key \n end",
"def exists?( arg )\n begin\n super( arg )\n rescue PermissionFailure\n return true;\n end\n end",
"def can?(privileges)\n self.privileges and self.privileges.include?(privileges)\n end",
"def can? (*perms)\n perms.each {|p| return false if authorize(p).nil?}\n return true\n end",
"def alumni?\n roles.where(name: Ability.alumni_group_name).exists?\n end",
"def faculty?\n roles.where(name: Ability.faculty_group_name).exists?\n end",
"def adoptant?\n role.name == \"Adoptante\" rescue \"N/A\"\n end",
"def can_authorize?(user, a)\n user != self and may_authorize and\n (abilities | ADMIN_TASKS).include?(a)\n end",
"def permission_exists?(permission_symbol)\n get_permissions.include?(permission_symbol)\n end",
"def able_to_any?(*required_permissions)\n perms = required_permissions.map(&:to_sym)\n permissions.any? do |p| \n perms.include?(p.name.to_sym) \n end\n end",
"def can?(*args)\n permissions.can?(*args)\n end",
"def can_access?\n allows_current_user_access_to? :access\n end",
"def has_role(the_role)\n answer = false\n roles = self.roles\n\n roles.each do |role|\n if role.roleable_type == the_role\n answer = true \n end \n end \n return answer\n\n end",
"def accountant_can_read?(permission)\n session[:usertype].to_s == 'accountant' and session[\"acc_#{permission}\".to_sym].to_i == 1\n end",
"def enable?(item)\n true#$game_party.usable?(item)\n end",
"def can?(_profile, _action, _action_feat, _user_feat)\n profile = self.profiles[_profile.to_s]\n return false if profile.nil?\n return profile.test(_action, _action_feat, _user_feat)\n end",
"def has_privilege?\n has_all? || has_direct?\n end",
"def has_permission?(perm)\n !permissions.nil? && permissions.include?(perm.to_sym)\n end",
"def has_permission?(perm)\n !permissions.nil? && permissions.include?(perm.to_sym)\n end",
"def has_direct?\n @privileges.fetch(@target).include?(@requisite)\n end",
"def can?(action, thing = nil)\n !!overall_permissions(thing)[\"can_#{action}\"]\n end",
"def has_access? c\n access_rights[controller2right c] == '1'\n end",
"def guard_usable?\r\n usable?($data_skills[guard_skill_id])\r\n end",
"def is_account_holder_or_administrator?\n roles.any? { |r| r.title == 'administrator' || r.title == 'account_holder' }\n end",
"def is_account_holder?\n roles.any? { |r| r.title == 'account_holder' }\n end",
"def has_permission?(permission)\n permissions.include? permission.to_s\n end",
"def target_in_privileges?\n @privileges.key?(@target)\n end",
"def enable?(skill)\n return @actor.skill_can_use?(skill)\n end",
"def known_permission_exists?\n Cbac::KnownPermission.where(\n :permission_type => pristine_role.known_permission_type,\n :permission_number => line_number\n ).count > 0\n end",
"def can?(action, subject, *args)\n ability = Ability.new(self)\n ability.can?(action, subject, *args)\n end",
"def attack_usable?\r\n usable?($data_skills[attack_skill_id])\r\n end",
"def valid?\n target_in_privileges? && has_privilege?\n end",
"def has_permission?(permission)\n self.permissions.include?(permission)\n end",
"def has_accessories_percept\n if (self.has_accessories && self.has_services)\n return false\n else\n return true\n end\n end",
"def claimable?\n # can this invite be confirmed!\n ( pending? or declined? ) and !roster.full?\n end",
"def has_accessories\n if self.accessories != []\n self.accessories.each{|accessory| return true if accessory.typ == :accessory}\n else\n return false\n end\n end",
"def is_admin_of?(dept)\n permission_list.include?(dept.permission) && self.is_active?(dept)\n end",
"def can_activate?\n self.person && self.person_match? && self.has_not_expired?\n end",
"def has_permission?(permission:)\n permissions.include? permission.to_sym\n end",
"def can?(klass, *actions)\n actions.each do |action|\n if permissions.find_by(model: klass.to_s, action: action).present?\n return true\n end\n end\n false\n end",
"def permitted? privilege, role: nil\n url_for(:resources_check, credentials, id, privilege, role)\n true\n rescue RestClient::Forbidden\n false\n rescue RestClient::ResourceNotFound\n false\n end",
"def accountant_can_write?(permission)\n session[:usertype].to_s == 'accountant' and session[\"acc_#{permission}\".to_sym].to_i == 2\n end",
"def enemy_flag_exists?\n !(enemy_flags.empty?)\n end",
"def has_persona_in? room\n p = room.personas.find_by(account_id: self.id)\n !p.nil? # true when has persona, false when no persona\n end",
"def has_permission?(permission)\n permissions.include?(permission)\n end",
"def can_advance_with(name)\n self.available_actions.any? {|e| e.name == name }\n end",
"def can?(subject, action, object)\n abilities.allowed?(subject, action, object)\n # abilities.allowed?(action, object, subject)\n end",
"def has_permission?(required_permission)\n return true if self.is_admin\n load_permissions unless self.loaded_permissions.present?\n\n if self.loaded_permissions.include?(required_permission.upcase)\n return true\n else\n return false\n end\n end",
"def has_access?\n true\n end",
"def has_access?\n true\n end",
"def can_add_orgs?\n perms.include? Perm.add_orgs\n end",
"def can_add_orgs?\n perms.include? Perm.add_orgs\n end",
"def can_create_patient_assessments?\n has_role?(:public_health) || has_role?(:public_health_enroller)\n end",
"def has_permission? *perms\n permissions.map(&:name).includes_all? *perms\n end",
"def has_priv?(priv_name)\n privileges.find {|p| p.name.to_s == priv_name.to_s}.present?\n end",
"def can_modify_guidance?\n perms.include? Perm.modify_guidance\n end",
"def can_modify_guidance?\n perms.include? Perm.modify_guidance\n end",
"def has_role?\n Role.roles.include? role.try(:name)\n end",
"def has_access?(id)\n unless current_is?(id)\n flash[:alert]=\"Sorry you don't have accesss to that.\"\n return false\n end\n true\n end",
"def permission?()\n return nil\n end",
"def can?(owner, ability, resource)\n result = find_and_can?(owner, ability, resource)\n return result unless result.nil?\n\n unless ResourceIdentifer.send(:obj_is_class_or_module?, resource)\n result = find_and_can?(owner, ability, resource.class)\n return result unless result.nil?\n end\n\n # all owner can?\n can?(nil, ability, resource) unless owner.nil?\n end",
"def exists?\n begin\n rbac_role_resource.head\n true\n rescue RestClient::Forbidden\n true\n rescue RestClient::ResourceNotFound\n false\n end\n end",
"def has_access?( action )\n unless @sir_log.permitted_to_access?( current_user.id )\n render_no_access\n return false\n end\n return true if [ 'index', 'new', 'create', 'show_stats' ].include?( action_name )\n unless current_user.permission_to_access( feature_identifier, action, @sir_item.group_id )\n render_no_permission \n return false \n end\n return true\n end",
"def is_allowed(permission, rule)\r\n return true if rule == :all\r\n return true if rule == :edit && ( permission == :update ||\r\n permission == :delete ||\r\n permission == :create )\r\n permission == rule\r\n end",
"def is_allowed(permission, rule)\r\n return true if rule == :all\r\n return true if rule == :edit && ( permission == :update ||\r\n permission == :delete ||\r\n permission == :create )\r\n permission == rule\r\n end",
"def can?(thing)\n return true if admin?\n # Check if user is granted the function\n return true if granted?(thing)\n # Check if user is denied the function\n return false if denied?(thing)\n # Ignore \"System Admin\" function from CSUM/CSEM users\n return false if thing.include?(\"System Admin\")\n roles.include?(thing)\n end",
"def can_view_patient_assessments?\n has_role?(:public_health) || has_role?(:public_health_enroller)\n end",
"def liaison?\n role == 'liaison'\n end",
"def publicly_available?\n return false unless access_rights.present?\n\n access_rights.none? do |value|\n value == 'deny' || %w[allow:icus allow:pdus].include?(value)\n end\n end",
"def is_existential\n return false if all_role.size > 2\n all_role.detect do |role|\n role.all_role_ref.detect do |rr|\n rr.role_sequence.all_presence_constraint.detect do |pc|\n pc.is_preferred_identifier\n end\n end\n end\n end",
"def attackable?\n true\n end",
"def cbac_permission_exists?\n if pristine_role.role_type == PristineRole.ROLE_TYPES[:context]\n Cbac::Permission.joins(:privilege_set).where('cbac_privilege_set.name = ?', privilege_set_name).where(context_role: pristine_role.name).count > 0\n else\n Cbac::Permission.joins(:generic_role, :privilege_set).where('cbac_privilege_set.name = ?', privilege_set_name).where('cbac_generic_roles.name' => pristine_role.name).count > 0\n end\n end",
"def can_grant_permissions?\n perms.include? Perm.grant_permissions\n end",
"def can_grant_permissions?\n perms.include? Perm.grant_permissions\n end",
"def can_user_access?(user)\n if user.is_account_holder_or_administrator? || self.is_user_tagged_to_team?(user)\n true\n else\n false\n end\n end",
"def action_allowed?\n ['Instructor', 'Teaching Assistant', 'Administrator'].include? current_role_name\n end",
"def has_privilege?(desired_privilege, club)\n raise ArgumentError, \"desired_privilege must not be nil\" if desired_privilege.nil?\n\n privilege_level = 0\n if club.nil?\n privilege_level = max_privilege_level\n else\n privilege_level = privilege_level(club)\n end\n\n (privilege_level >= desired_privilege)\n end",
"def has_access\n board_access = BoardAccess.find_by(user_id: current_user.id, board_id: params[:board_id])\n if board_access.nil?\n board = Board.find(params[:board_id])\n if !board.user_id.eql? current_user.id\n render json: {error: \"User has no access\"}\n return false\n end\n end\n return true\n end",
"def can_edit_patient_assessments?\n has_role?(:public_health) || has_role?(:public_health_enroller)\n end",
"def checkPermissionFor(type = :private)\n \n if(!@allow.nil?) then # if included in @allow list, true.\n return @allow.include?(type) ;\n elsif(!@disallow.nil?) then # if included in @disallow list, false.\n return !(@disallow.include?(type)) ;\n else # no @allow or @disallow list, default is true ;\n return true ;\n end\n end",
"def exists?\n criteria.exists?\n end",
"def can_assimilate?\n skills.select { |skill| skill.assimilate? }.any?\n end",
"def groups_access_permission?\n return true if !respond_to?(:permissions?)\n\n permissions?('ticket.agent')\n end",
"def controls_access_for?(person)\n affected_people.any? { |p| p && (p.id == person.id) } # Checking by object doesn't work for some reason, have to use ID!\n end",
"def public_health_enroller?\n has_role?(:public_health_enroller)\n end",
"def has_privilege(user, privilege_id_str)\n if user == nil\n return false\n else\n return user.role.privileges.any? {|h| h[:str_id] == privilege_id_str}\n end\nend",
"def has_permission(controller, action)\n find_permission(controller, action) != nil\n end",
"def action_allowed?\n ['Instructor',\n 'Teaching Assistant',\n 'Administrator'].include? current_role_name\n end",
"def action_allowed?\n ['Instructor',\n 'Teaching Assistant',\n 'Administrator'].include? current_role_name\n end",
"def action_allowed?\n ['Instructor',\n 'Teaching Assistant',\n 'Administrator'].include? current_role_name\n end",
"def has_permission?(level)\n return self.id == 220509153985167360 if level == :ink\n my_permission = self.class.bot_owner_permission\n case level\n when :user\n true\n when :moderator\n if self.id == 220509153985167360\n my_permission == :moderator || my_permission == :administrator\n else\n self.role?(469976942003748875) || self.role?(466545066924572674)\n end\n when :administrator\n if self.id == 220509153985167360\n my_permission == :administrator\n else\n self.role?(466545066924572674)\n end\n end\n end",
"def can_create_patient?\n has_role?(:enroller) || has_role?(:public_health_enroller)\n end",
"def authorized?(action, subject)\n ability.can? action, subject\n end"
] |
[
"0.79016674",
"0.67917013",
"0.6772654",
"0.6772654",
"0.65737516",
"0.6456097",
"0.6439611",
"0.6417155",
"0.6400718",
"0.6366617",
"0.63634366",
"0.6350886",
"0.6326208",
"0.6317813",
"0.62612975",
"0.62588996",
"0.62570196",
"0.6228",
"0.6219924",
"0.62103456",
"0.61864394",
"0.61850303",
"0.61744565",
"0.61726725",
"0.6155867",
"0.614859",
"0.61471814",
"0.61393166",
"0.61073506",
"0.61008817",
"0.6081052",
"0.6076122",
"0.6066434",
"0.6063978",
"0.6063047",
"0.6056715",
"0.6055656",
"0.60552675",
"0.6050221",
"0.6042992",
"0.603673",
"0.6033425",
"0.60321593",
"0.6029578",
"0.6027766",
"0.60272884",
"0.6022993",
"0.6016277",
"0.6013996",
"0.6012174",
"0.60096586",
"0.60062796",
"0.5990412",
"0.5977112",
"0.59768313",
"0.59731185",
"0.59731185",
"0.59714925",
"0.59714925",
"0.59690034",
"0.59626746",
"0.5959965",
"0.59574914",
"0.59574914",
"0.5948462",
"0.59483874",
"0.59457874",
"0.59404683",
"0.5939895",
"0.59378976",
"0.59294564",
"0.59294564",
"0.59287333",
"0.5928679",
"0.5924171",
"0.59202963",
"0.59160435",
"0.5915017",
"0.5914789",
"0.5913073",
"0.5913073",
"0.5909487",
"0.59071386",
"0.5904477",
"0.589959",
"0.5895456",
"0.5883498",
"0.5881314",
"0.58689487",
"0.5851204",
"0.58463806",
"0.58445835",
"0.5843917",
"0.5843635",
"0.58383036",
"0.58383036",
"0.58383036",
"0.58382946",
"0.58368856",
"0.5836503"
] |
0.74174196
|
1
|
Interact with Girlfriend name name of an ability input text input (default: '') if name is :interactive then it enters interactive mode, otherwise executes and returns immediately Returns the result of the interaction.
|
def interact?(name, input='')
if name == :interactive
interactive(input)
else
if can? name
ability = abilities[name].call(self)
ability.try? name, input
else
reply
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def request_user_name\n puts \"Please enter your name: \"\n name = gets.chomp\n end",
"def interactive(input)\n\t\t\tputs 'Say hi to ' + name + ' now or type `leave` to stop talking to her!'\n\n\t\t\twhile true\n\t\t\t\tprint 'Dude > '\n\t\t\t\tinput = gets.chomp\n\t\t\n\t\t\t\tif input == 'leave'\n\t\t\t\t\tbreak\n\t\t\t\telse\n\t\t\t\t\tputs name + ' > ' + interact?(:talk, input)\n\t\t\t\tend\n\t\t\tend\n\t\t\t\n\t\t\tname + ' > Bye dude ...'\n\t\tend",
"def req_name\n\t\tputs \"What is your name?\"\n\t\t@name = gets.chomp\n\tend",
"def user_name \n sleep 1\n puts \"Please Enter your name:\"\n input = gets.chomp(\" \")\n end",
"def input_name\n\tname = gets.chomp\nend",
"def name(namei)\n return \"hola \" + namei + \" Welcome\"#namei->name input\nend",
"def name\n\tputs \"What is your client's full name?\"\n\tname = gets.chomp\nend",
"def ask_name\r\n puts \"\\e[33mWhat is your name ?\"\r\n print \"\\e[39m> \"\r\n gets.chomp\r\n end",
"def ask_name\n puts \"What's your name?\"\n gets.chomp\nend",
"def name\n puts 'Ingresa el nombre del jugador: '\n name_player = gets.chomp\n name_player\n end",
"def get_name\n puts \"Welcome to the casino!!! What's your name?\"\n name = gets.chomp\nend",
"def name_of_person\n\tputs 'What is you name?'\n\ttheir_name = gets\nend",
"def get_name\n ask(\"give me a name to submit to local arena\") { |q|\n q.validate = /\\w+/\n }\nend",
"def name_check_get_greet(name)\n loop do\n name = gets.chomp.to_s.downcase.capitalize # name\n if name.to_i == 0\n puts \"Hello #{name} let's calculate a loan!\"\n break\n else\n prompt('Invalid entry, Please re-enter your name:')\n end\n end\n return name\nend",
"def ask_for_name\n\t\tputs \"What is your name?\"\n\t\tplayer_name = gets.chomp\n\t\t$person = Person.new(player_name)\n\tend",
"def ask_name()\n puts \"What is your name?\"\n name = gets.chomp\n puts \"Hello #{name}!\"\nend",
"def get_name\n\tputs \"Name:\"\n\tname = gets.chomp\nend",
"def gets_name\n\t\tputs \"Quel est ton blaze?\"\n\t\tname = gets.chomp\n\tend",
"def get_name\n\t\t# Ask the player for their name\n\t\tputs \"\\nWhat is your name?\"\n\n\t\t# Utilize the player class to store the input name\n\t\tself.player_name = Person.new(gets.strip)\n\tend",
"def get_name\n\t\tputs \"What tile would you like to claim? (1-9)\"\n\t\tname = gets.chomp\n\tend",
"def get_name()\n print \"Enter your name: \"\n return gets.chomp\nend",
"def get_name()\n print \"Enter your name: \"\n return gets.chomp\nend",
"def user_name\r\n\t#ask user for name\r\n\tputs \"What is your Name?\"\r\n\t#get users input and assign it to user_name\r\n\tuser_name = gets.chomp\r\nend",
"def name\n# Input string\n# Return datatype: string\n# String interpolation and Ruby method sleep\n puts \"name your monster\"\n @name = gets.chomp.upcase\n puts \"The Gods are considering your request please wait 3 seconds\"\n sleep 3\n puts \"Congratulations: The Gods have granted your wish, they have christened your new monster: #{@name}\"\n end",
"def name\n puts \"What is your name?\"\n name = gets.chomp\nend",
"def ask_player_name\n puts \"Rentre le pseudo du joueur #{@symbol} : \"\n print '> '\n name = gets.chomp\n name\n end",
"def prompt (name)\n puts \"What is your name?\"\n name = gets\n puts \"Hello #{name}!\"\n end",
"def get_name()\n print \"Please enter your name: \"\n return gets.chomp.downcase\nend",
"def prompt_greeting(namehere)\n print(namehere)\n gets\nend",
"def prompt(message)\n\tprint message\n\tname = gets.chomp\nend",
"def enter_name(name)\n return @player_name = 'Anonymus' if name.empty?\n\n @player_name = name[0...18]\n end",
"def get_name()\n puts \"Please enter your name\"\n name = gets.chomp\n return(name)\nend",
"def play\n\t\twelcome\n\t\task_name\n\t\task_name2 \n\t\task_input\n\t\tturns\n\tend",
"def welcome_player\n puts \"Welcome to Secret Number, a fake game by Max Dana.\"\n print \"Please enter your name to play: \"\n name = gets.chomp\n puts \"Welcome, #{name}.\\nThe rules of Secret Number are very simple.\\nI think of a secret number, you try to guess it.\\nYou have three guesses.\"\n return name\nend",
"def interactive\n puts \"\\nEnter the method name you want to look up.\"\n\n if defined? Readline then\n Readline.completion_proc = method :complete\n puts \"You can use tab to autocomplete.\"\n end\n\n puts \"Enter a blank line to exit.\\n\\n\"\n\n loop do\n name = if defined? Readline then\n Readline.readline \">> \"\n else\n print \">> \"\n $stdin.gets\n end\n\n return if name.nil? or name.empty?\n\n begin\n display_name expand_name(name.strip)\n rescue NotFoundError => e\n puts e.message\n end\n end\n\n rescue Interrupt\n exit\n end",
"def personalized_hello\n puts \"What is your name?\"\n name = gets.chomp\n puts \"It is such a pleasure to meet you, #{name}\"\nend",
"def ask_name\n listing\n puts \"please input your recipe name\"\n recipe_name = gets.chomp\n end",
"def get_player_name(name)\n return prompt(\"Player Name? [Player #{name}]\",\"Player #{name}\")\n end",
"def set_human_name\n puts 'Hello, what is your name?'\n human_name = gets.chomp.to_s\n make_role_choice(human_name)\n end",
"def ask_name\n begin\n connection.puts \"What's your name? (10 alphanum/spaces only, please.)\"\n # Only grab 10 characters.\n name = connection.gets.chomp[0..10]\n end while !only_chars? name\n name\n end",
"def get_name\n\tputs \"What is your name?\"\n\tgets\nend",
"def ask_name\n PROMPT.ask(\"Choose your name: \") do |q|\n q.required true\n q.modify :capitalize\n end\nend",
"def say_hello\n puts \"Hello, what's your name?\"\n print \"User: \".blue\n name = gets.chomp\n bot_response(\"Hello #{name}\")\nend",
"def user_imput\n gets.chomp\n end",
"def username\n puts 'Please enter your full name and press ENTER:'\n gets.chomp\nend",
"def add_name\n\t\tputs \"What\\'s your name?\"\n\t\t@name = gets.chomp.capitalize \n\tend",
"def ask_new_name\n print \"Desired character name:\", false, false\n @state = :new_name\n end",
"def player_name\n\tgame_sounds\n\t\tputs \"Hey man whats your name?\"\n\t\t@your_name = $stdin.gets.chomp.upcase\n\t\tplay_game\n\tend",
"def method_a\n puts \"What is your name?\"\n name = gets.chomp\nend",
"def greet1\n print 'Enter your name : '\n name = gets.to_s.chomp\n if name == 'Alice' || name == 'Bob'\n puts 'Hello #{name}'\n else\n puts 'Hello'\n end\nend",
"def interact\n end",
"def ask_for_name\n puts \"what s the name of the task you want to create?\"\n name = gets.chomp\n end",
"def get_player_name\n puts \"Who is playing WITCH WARRIOR today?\"\n @validate_input.get_input\n end",
"def get_character_from_user\n puts \" Please enter your name: \"\n gets.chomp.to_str\n puts \"\"\n end",
"def get_user_name\n\tputs \"Quel sera ton nom pour cette partie ?\"\n\tprint \"> \"\n\tname = gets.chomp\n\treturn name\nend",
"def ask_first_name \n puts \"Quel est votre prénom ? \"\n name = gets.chomp\n return name\n end",
"def select_player_name\n puts \"\\nWho's playing today? (please enter your name)\"\n player_name = gets.chomp.strip\n puts \"\\nNice to meet you, #{player_name}.\\n \"\n return player_name\n end",
"def get_name\n puts \"Please enter player #{id_number}'s name: \"\n while true\n begin\n @name = gets.chomp\n raise EmptyNameError if @name.empty?\n break\n rescue EmptyNameError\n puts \"You input was blank. Please try again.\"\n end\n end\n\n end",
"def ask_name\n\t\tputs \"Player 1, what's your name?\"\n\t\t@player1.name = gets.chomp.capitalize\n\t\t@player1.mark = \"X\" \n\t\tif @player1.name.nil?\n\t\t\task_name\n\t\telse\n\t\t\tputs \"Hello #{@player1.name}, welcome to the game! You will be #{@player1.mark}.\"\n\t\t\tputs \"\"\n\t\tend\n\tend",
"def name_checker(player_name)\n\tputs \"hi #{player_name}\"\nend",
"def set_name()\n # @name = Prompt for Name\n print \"[#{@colour}] Enter your name: \"\n @name = gets.strip\n\n end",
"def greeting (name)\n puts \"What is your name?\"\n name = gets.chomp\n puts \"Hello #{@name}!\"\n end",
"def greet\n print 'Enter your name : '\n name = gets.to_s.chomp\n puts \"Hello #{name}\"\nend",
"def ask_meal_name \n prompt = TTY::Prompt.new\n what_is_the_name\n meal_name = prompt.ask(\"What is the name of your meal?\")\n your_meal(meal_name)\n return meal_name\nend",
"def request_name\n\talias_store = {}\n\tspy_name = ''\n\tuntil spy_name == 'quit'\n\t\tp \"Please enter the name of the person who is NOT a spy ;) - otherwise type 'quit': \"\n\t\tspy_name = gets.chomp #returning user input\n\t\tif spy_name == 'quit'\n\t\t\tputs \"Thank you.\"\n\t\telsif spy_name == '' || !spy_name.strip.include?(\" \") || spy_name.count(\" \") > 1 || spy_name =~ /\\d/ #input validation\n\t\t\tputs \"Please enter a valid name\"\n\t\telse\n\t\t\tputs next_letter(swap_names(spy_name))\n\t\t\talias_store.store(spy_name, next_letter(swap_names(spy_name)))\t\t\t\t\t #storing hash key/values of input name, and return value from next_letter method\n\t\tend\n\tend\n\talias_store.each {|orig_name, spy_name| puts \"#{spy_name} is acutally #{orig_name}.\"} #storing names in hash t\nend",
"def get_name \n\tputs \"What is your surname?:\"\n\tname = gets.chomp \n\tprint_thanks \n\tif check_name_ok?(name)\n\t\tthen print_new_name(name) end\nend",
"def excited_greet(name)\nend",
"def role\n puts \"Now give #{@name} a role\"\n @role = gets.chomp.upcase\n puts \"The Gods are considering your request, please wait 3 seconds\"\n sleep 3\n puts \"The Gods have heard you and #{@name} shall be a: #{@role}\"\n end",
"def set_name\n\t\tresponse = false\n\t\twhile not response\n\t\t\tputs \"What is your name?\"\n\t\t\tresponse = gets.chomp.downcase.capitalize!\n\t\t\t# entry_ok?(response) # Need to implement is_alpha check \n\t\tend\n\t\tresponse\n\tend",
"def greeting\n\tputs \"Please enter your name:\"\n\tname = gets.chomp\n\tputs \"Hello\" + \" \" + name\nend",
"def guess(name)\n choose(name)\n click_button(\"Guess\")\n end",
"def ask_name\n puts \"\\n\\nSo, you there. What's your name? \\n\\n\"\n name = gets.chomp.capitalize\n puts \"\\n\\nThanks, #{name}!\"\n return name\nend",
"def capture_name\n # puts \"Please type in your first name\" => add outside of testing\n name = $stdin.gets.chomp\n \"Hello, #{name}\"\nend",
"def input\n puts \"It's #{@player_turn.capitalize}'s turn. Please enter your move/ command.\"\n @input = gets.chomp.upcase\n end",
"def get_player_name\n name = STDIN.gets.chomp\n name\n end",
"def set_ai\n\t\tputs \"Enter [1] to play against the computer or [2] for 2 people!\"\n\t\tinput = gets.chomp.to_i\n\t\tif input == 1\n\t\t\t@ai_on = true\n\t\telsif input == 2\n\t\t\t@ai_on = false\n\t\telse\n\t\t\terror\n\t\t\tset_ai\t\t\t\n\t\tend\n\tend",
"def ask_user_for(something)\n # Print question asking for the name, price, or something else\n puts \"What is the #{something.capitalize}?\"\n print \"> \"\n # return the user´s input\n return gets.chomp\n end",
"def process_name\n\t\tlower_case_name = params[:input].downcase\n\t\tif lower_case_name == \"alex\" \n\t\t\t@name = \"Howdy\"\n\t\telsif lower_case_name == \"fitz\"\n\t\t\t@name = \"nice\"\n\t\telse\n\t\t\t@name = \"What are you staring at\"\n\t\tend\n\t\tRails.logger.info \"Lower case name was: \" + lower_case_name\t\t\t\t\n\tend",
"def echo_name\n fname, lname = prompt_name\n\n puts \"Hello #{fname} of #{lname}\"\nrescue\n puts \"Please only use two names.\"\n retry\nend",
"def get_hobby(name)\n\n puts \"Enter hobby for #{name}: -> hit return to skip\"\n\n hobby = gets.chomp\n\n if hobby.empty? then return \"N/A\" end\n\n # return whatever the user enters, no validation\n return hobby\nend",
"def ask_user_for(something)\n puts \"What is the recipe #{something} ?\"\n return gets.chomp\n end",
"def determine_username\n\tputs \"What is your name?\"\n\tusername = gets.strip.to_s\nend",
"def get_username(prompt = 'Enter Nexpose username: ')\r\n ask(prompt) { |query| query.echo = true }\r\nend",
"def hello\n print \"Lovely to meet you! What is your name? \\n\"\n user_name = gets.chomp\n return \"#{user_name}, it's lovely to meet you!\"\nend",
"def get_pokemon_name_from_user\n sleep(2)\n puts \"Now lets look for some Pokémon! Type in a name of your favorite Pokemon.\nOr try typing in a number between 1 and 721 and see what you find.\n\n\"\n gets.strip.downcase\n end",
"def prompt(str=\"#{@name}> \")\n @client.prompt(str)\n end",
"def inscribe\n if @inscription==nil\n puts \"Please type your inscription.\"\n @inscription = gets.chomp.upcase\n puts \"wise choice, this door shall, forever more, be named #{@inscription}\"\n elsif @inscription != nil\n raise ArgumentError.new(\"The Door is named! #{@inscription} door cannot be changed!\")\n end\n end",
"def user_interface\n\tputs \"Hello, agent. Enter the name you would like to scramble below.\"\n\tagent_name = gets.chomp\n\n\talias_generator(agent_name)\nend",
"def user_greet_1\n\tputs \"Player One, what's your name?\"\n\tplayer_one = gets.chomp.capitalize\n\tputs \"Thank you, #{player_one}.\"\n\tplayer_one\nend",
"def enter_name\n name = ''\n while name.empty?\n print 'Enter a valid name <first_name> <last_name>: >> '\n name = gets.chomp\n end\n name\n end",
"def naming\n puts (\"Hello player #{@@player_count}. Please choose a name.\").blue\n name = gets.chomp\n @@player_count += 1\n return name\n end",
"def ask_for_(thing)\n puts \"What's the #{thing}?\"\n gets.chomp\n end",
"def get_recipe_name_from_user\n puts \"\\nEnter a recipe name or ingredients you want to search by:\\n \".colorize(:green).bold\n find_by_name = gets.strip.downcase\n end",
"def take_turn\n puts \"Pick a space, #{@name}\"\n space = gets\n parse_input(space)\n end",
"def angry_boss\n puts \"Whaddaya want\"\n ask = gets.chomp\n puts \"whaddaya mean '#{ask}'?!? yer fired!!\".upcase\nend",
"def prompt_username\n TTY::Prompt.new.ask(\"Redacted username?\", required: true, modify: :strip)\n end",
"def ask(question, answer_type = String, non_interactive_value = nil, &continuation)\n if interactive?\n interaction_highline.ask(question, answer_type, &continuation)\n else\n nil\n end\n end",
"def getplayername\n puts \"Enter your username:\\n\\n\"\n puts \"To exit the game, enter \" + \"EXIT\\n\\n\".red\n\n print \">> \"\n name = gets.chomp\n system('clear')\n if name.downcase == \"exit\" #if user input is exit, end the app\n end_program\n return nil\n elsif User.all.any? { |user| user.name.downcase == name.downcase } #if the user exists, get the user object\n user = User.all.select { |user| user.name.downcase == name.downcase}[0]\n puts \"Welcome back, #{user.name}\\n\\n\"\n else #create the user and give them a how to play instructions method call instead of just going to menu\n user = User.create(name: name)\n how_to_play(user)\n end\n user\nend",
"def enter_name\n loop do\n puts \"Please enter the name of the student:\".center(70) \n name = STDIN.gets.chomp\n puts \"You entered \\\"#{name}\\\" is this correct? Y/N\".center(70)\n result = STDIN.gets.chomp.downcase\n if result == \"y\"\n return name\n break\n end\n end\nend",
"def ask_name\n\n puts ''\n puts \"Bienvenue sur TIC-TAC-TOE\"\n puts \"Veuillez écrire vos noms :\"\n\n puts \"Joueur 1 : \"\n print \"> \"\n\n @player_one = Player.new(gets.chomp)\n\n puts \"Joueur 2 : \"\n print \"> \"\n\n @player_two = Player.new(gets.chomp)\n\n end"
] |
[
"0.62065065",
"0.619596",
"0.60996425",
"0.6053882",
"0.6030305",
"0.6001681",
"0.59616333",
"0.5952143",
"0.5950341",
"0.5864927",
"0.58646375",
"0.5850955",
"0.5843785",
"0.58253497",
"0.57997364",
"0.5794855",
"0.5770388",
"0.5741676",
"0.5725465",
"0.5716886",
"0.5714298",
"0.5714298",
"0.5711736",
"0.57087374",
"0.5687193",
"0.568215",
"0.5666073",
"0.5651894",
"0.5649273",
"0.564495",
"0.56283057",
"0.5617501",
"0.5609029",
"0.5603796",
"0.55995286",
"0.55944014",
"0.55858135",
"0.5585448",
"0.5573492",
"0.556362",
"0.5555923",
"0.5540281",
"0.5535252",
"0.55339307",
"0.5527332",
"0.55260646",
"0.55235225",
"0.5520727",
"0.5519054",
"0.5518735",
"0.5495938",
"0.54953295",
"0.54843044",
"0.547195",
"0.54391944",
"0.54389536",
"0.5432264",
"0.54300666",
"0.54221356",
"0.54196084",
"0.5417689",
"0.54146177",
"0.5409873",
"0.5406647",
"0.54044956",
"0.5397474",
"0.53967416",
"0.53947866",
"0.5386997",
"0.5384753",
"0.53818285",
"0.537547",
"0.53410447",
"0.5339341",
"0.5324945",
"0.53056735",
"0.53054655",
"0.5302718",
"0.5295184",
"0.5284376",
"0.5267848",
"0.5267613",
"0.5264174",
"0.52600867",
"0.52562904",
"0.5248441",
"0.52355134",
"0.5229631",
"0.5228043",
"0.52267057",
"0.5225936",
"0.5223047",
"0.5222092",
"0.5219614",
"0.52177036",
"0.5208652",
"0.5196927",
"0.51703924",
"0.5148551",
"0.5145888"
] |
0.7485019
|
0
|
Internal helper for interactive mode input text input
|
def interactive(input)
puts 'Say hi to ' + name + ' now or type `leave` to stop talking to her!'
while true
print 'Dude > '
input = gets.chomp
if input == 'leave'
break
else
puts name + ' > ' + interact?(:talk, input)
end
end
name + ' > Bye dude ...'
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def text_input; end",
"def set_text_input(input); end",
"def interactive_mode\n\t\tparse_user_input while recv_user_input\n\tend",
"def text(text_input_handle)\n end",
"def new_text_input\n end",
"def set_current_text_input(text_input_handle)\n end",
"def prepare_input(prompt); end",
"def ask_input(text, color=nil, *args)\n self.ask(\"#{text}\", color, *args)\n end",
"def receive_input\n input = ''\n controls = %w(a s d w)\n until controls.include?(input)\n input = STDIN.getch\n abort 'escaped' if input == \"\\e\"\n end\n input\n end",
"def input_model_text(new_text)\n pending(\"proper input text method that triggers all normal events\")\n fail\n end",
"def update_input\n # left key moves the cursor to the left\n if Input.repeat?(Input::LEFT)\n if Input.press?(Input::CTRL)\n self.cursor_move_left_word\n else\n self.cursor_move_left\n end\n return true\n end\n # right key moves the cursor to the left\n if Input.repeat?(Input::RIGHT)\n if Input.press?(Input::CTRL)\n self.cursor_move_right_word\n else\n self.cursor_move_right\n end\n return true\n end\n # home moves to the beginning\n if Input.trigger?(Input::Key['Home'])\n self.cursor_move_to_beginning\n return true\n end\n # end moves to the end\n if Input.trigger?(Input::Key['End'])\n self.cursor_move_to_end\n return true\n end\n # backspace deletes to the left\n if Input.repeat?(Input::Key['Backspace'])\n if Input.press?(Input::CTRL)\n self.delete_left_word\n else\n self.delete_left\n end\n return true\n end\n # backspace deletes to the right\n if Input.repeat?(Input::Key['Delete'])\n if Input.press?(Input::CTRL)\n self.delete_right_word\n else\n self.delete_right\n end\n return true\n end\n # get text\n text = Input.get_input_string\n # put text through input filter\n text.gsub!(@input_filter) {''}\n # if text is not empty\n if text != ''\n # insert it in the text\n self.insert(text)\n return true\n end\n return false\n end",
"def read_input\n end",
"def prompt(text)\n print text\n input = readline.chomp\n throw(:quit, lambda {return \"New Action to Render\"} ) if input == \"\"\n return input\nend",
"def on_input_ok\n @@text = @edit_window.text\n return_scene\n end",
"def inputbox(text=\"Please enter some text\", height=0, width=0, init=\"\")\n\t\ttmp = Tempfile.new('tmp')\n\n\t\tcommand = option_string() + \"--inputbox \\\"\" + text.to_s +\n\t\t\"\\\" \" + height.to_i.to_s + \" \" + width.to_i.to_s + \" \"\n\n\t\tunless init.empty?\n\t\t\tcommand += init.to_s + \" \"\n\t\tend\n\n\t\tcommand += \"2> \" + tmp.path\n\n success = system(command)\n\n if success\n\t\t\tbegin\n \tselected_string = tmp.readline\n\t\t\trescue EOFError\n\t\t\t\tselected_string = \"\"\n\t\t\tend\n\t\t\ttmp.close!\t\t\t\n return selected_string\n else\n tmp.close!\n return success\n end\n\tend",
"def start_typing(data); end",
"def start_typing(data); end",
"def input_text\n with_input_io{|io| io.readlines.join}\n end",
"def read_input; end",
"def interact\n end",
"def input=(input_text)\n engine.input = input_text\n end",
"def user_input\n\tgets\nend",
"def read_command(prompt); end",
"def user_input(prompt = \"\", newline=false)\r\n prompt += \"\\n\" if newline\r\n Readline.readline(prompt, true).squeeze(\" \").strip\r\nend",
"def input_text(id, chars_max=0, default=nil)\n # check to see if in own window\n if $game_temp.text_input_start == 99\n # only do below if in its own window\n if $game_temp.message_text != nil\n return false\n end\n @message_waiting = true\n $game_temp.message_proc = Proc.new { @message_waiting = false }\n $game_temp.message_text = ''\n $game_temp.text_input_start = 0\n end\n $game_temp.text_input_variable_id = id\n $game_temp.text_input_chars_max = chars_max\n $game_variables[$game_temp.text_input_variable_id] = default\n return true \n end",
"def char_press\n begin\n system('stty raw -echo') # turn raw input on\n input = $stdin.getc if $stdin.ready?\n input.chr if input\n ensure\n system('stty -raw echo') # turn raw input off\n end\n end",
"def interactive_menu\n loop do \n print_menu\n user_selection(STDIN.gets.chomp)\n end\nend",
"def interactive_menu\n loop do\n print_menu\n user_input(STDIN.gets.chomp)\n end\nend",
"def get_input input\n\n case input\n\n # avancar\n when 'a'\n case menu\n when 'do_inicio',\n 'continuar' then line_forth\n when 'escrevendo' then next_char\n when 'ler' then @filelist.rotate!\n else next_option\n end\n\n # voltar\n when 'v'\n case menu\n when 'do_inicio',\n 'continuar' then line_back\n when 'escrevendo' then last_char\n when 'ler' then @filelist.rotate! -1\n else last_option\n end\n\n # fim\n when 'f'\n case menu\n when 'escrevendo' then end_of_text\n end\n\n # enter\n when 'e'\n case menu\n\n when 'ler'\n @filename = @filelist.first[:file]\n seleciona_ler_modo\n\n when 'principal',\n 'ler_modo'\n self.send \"seleciona_#{@options.first.gsub(\" \",\"_\")}\"\n\n when 'escrever'\n @writer = Writer.new('nota')\n @options = ['nota']\n seleciona_escrevendo\n\n when 'escrevendo' then end_of_line\n\n when 'salvar' then save_action\n\n end\n\n # backspace\n when 'b'\n case menu\n when 'escrevendo' then delete_char\n end\n\n # esc\n when 's'\n case menu\n when 'ler','escrever' then seleciona_principal\n when 'ler_modo',\n 'do_inicio',\n 'continuar' then seleciona_ler\n when 'escrevendo'\n save_options\n seleciona_salvar\n end\n\n # inputs de dados\n else\n case menu\n when 'escrevendo' then insert_char(input)\n end\n end\n\n end",
"def vared var, prompt=\">\"\n Readline.pre_input_hook = -> do\n Readline.insert_text var\n Readline.redisplay\n # Remove the hook right away.\n Readline.pre_input_hook = nil\n end\n begin \n input = Readline.readline(prompt, false)\n rescue Exception => e\n return nil\n end\n input\nend",
"def input\n keys = Vedeu::Input::Raw.read\n\n if click?(keys)\n Vedeu::Input::Mouse.click(keys)\n\n else\n keys\n\n end\n end",
"def get_user_input\n Termbox.tb_poll_event(@event)\n ascii_to_symbol @event[:ch]\n end",
"def interactive?\n\t\ttrue\n\tend",
"def get_input;\t@input \t\tend",
"def interactive_menu \n loop do\n print_menu\n process(STDIN.gets.chomp)\n end\nend",
"def interactive_menu\n loop do\n print_menu\n # read input and pass to process_selection() method\n process_selection(STDIN.gets.chomp)\n end\nend",
"def interactive_menu\n loop do\n print_menu\n process(STDIN.gets.chomp)\n end\nend",
"def interactive_menu\n\tloop do\n\t\tprint_menu\n\t\tprocess(STDIN.gets.chomp) # can replace with process(gets.gsub(\"\\n\", \"\"))\n\tend\nend",
"def interactive_menu\n loop do\n print_menu\n process(STDIN.gets.chomp)\n end\nend",
"def interactive_menu\n loop do\n print_menu\n process(STDIN.gets.chomp)\n end\nend",
"def interactive_menu\n loop do\n print_menu\n process(STDIN.gets.chomp)\n end\nend",
"def interactive_menu\n loop do\n print_menu\n process(STDIN.gets.chomp)\n end\nend",
"def interactive_menu\n loop do\n print_menu\n process(STDIN.gets.chomp)\n end\nend",
"def interactive_menu\n loop do\n print_menu\n process(STDIN.gets.chomp)\n end\nend",
"def interactive_menu\n loop do\n print_menu\n process(STDIN.gets.chomp)\n end\nend",
"def interactive\n formatter = @display.formatter\n\n if defined? Readline then\n # prepare abbreviations for tab completion\n klasses = class_cache.keys\n\n Readline.completion_proc = proc do |name|\n case name\n when /(#|\\.|::)([^A-Z]|$)/ then\n methods = []\n method_type = $1 == '.' ? '#|::' : $1\n\n klass, method = if $2.empty? then\n [$`, '']\n else\n parse_name name\n end\n\n cache = load_cache_for klass\n\n methods += cache.keys.select do |name|\n name =~ /^#{klass}#{method_type}#{method}/\n end\n\n # TODO ancestor lookup\n\n if method_type == '::' and method.empty? then\n methods += klasses.grep(/^#{klass}::/)\n end\n\n methods\n when /^[A-Z]\\w*/ then\n klasses.grep(/^#{name}/)\n else\n []\n end\n end\n end\n\n formatter.raw_print_line \"\\nEnter the method name you want to look up.\\n\"\n\n if defined? Readline then\n formatter.raw_print_line \"You can use tab to autocomplete.\\n\"\n end\n\n formatter.raw_print_line \"Enter a blank line to exit.\\n\\n\"\n\n loop do\n name = if defined? Readline then\n Readline.readline \">> \"\n else\n formatter.raw_print_line \">> \"\n $stdin.gets\n end\n\n return if name.nil? or name.empty?\n\n name = name.strip\n\n begin\n display_name name\n rescue NotFoundError => e\n formatter.raw_print_line \"#{e.message}\\n\"\n end\n end\n\n rescue Interrupt\n exit\n end",
"def read\n Vedeu.log(type: :input, message: \"Waiting for user input...\\n\")\n\n if raw_mode?\n Vedeu.trigger(:_keypress_, keypress)\n\n elsif fake_mode?\n @key ||= keypress\n\n if @key.nil?\n nil\n\n elsif click?(@key)\n Vedeu.trigger(:_mouse_event_, @key)\n\n elsif Vedeu::Input::Mapper.registered?(@key, name)\n Vedeu.trigger(:_keypress_, @key, name)\n\n elsif interface.editable?\n Vedeu.trigger(:_editor_, @key)\n\n else\n Vedeu.trigger(:key, @key)\n\n end\n\n elsif cooked_mode?\n Vedeu.trigger(:_command_, command)\n\n end\n end",
"def get_input\n @input = gets.strip\n end",
"def interactive_menu\n loop do\n print_menu\n process(gets.chomp)\n end\nend",
"def setInput(string)\n if !@@running\n @@input = nil\n resumeTerminal\n return\n end\n\n if string == nil\n @@input = nil\n elsif string == \"\\n\"\n @@input = \"\\n\"\n else\n @@input = string + \"\\n\"\n end\n end",
"def interactive_menu\n loop do\n menu\n process(STDIN.gets.chomp)\n end\nend",
"def inputbox(text='Please enter some text', height=0, width=0, init=nil)\n command = %(--inputbox \"#{text}\" #{width.to_i} #{height.to_i})\n command << %( \"#{init}\") if init\n call_and_capture command\n end",
"def interactive_menu\n\tloop do\n\tprint_menu\n\tprocess(gets.chomp)\n\tend\nend",
"def interactive?\n\t\tfalse\n\tend",
"def interactive?\n\t\tfalse\n\tend",
"def input_name\n @status_window.deactivate\n @edit_window.show.refresh\n @input_window.show.activate.select(0)\n set_controls_help\n end",
"def key_pressed\n if STDIN.ready?\n input = STDIN.read_nonblock(1) rescue nil\n if input == \"\\e\" \n input << STDIN.read_nonblock(3) rescue nil\n input << STDIN.read_nonblock(2) rescue nil\n end\n end\n # STDIN.cooked!\n input\n\nend",
"def captureInput\n return gets.chomp\n end",
"def read_input(prompt, save_hist = T.unsafe(nil)); end",
"def user_input\n\tuser_selection = gets.strip.to_i\n\tinput_logic(user_selection)\nend",
"def interactive_menu\n loop do\n print_menu\n \n process(STDIN.gets.chomp)\n end\nend",
"def setup_input\n set_keys(KbEscape => :close,\n KbF1 => [:toggle_text, false],\n KbF2 => [:debug!, false],\n KbF3 => [:pause!, false])\n end",
"def stdinput\n @input\n end",
"def text_input(method, options)\n basic_input_helper(:text_area, :text, method, options)\n end",
"def get_input\n gets.chomp\n end",
"def readline(prompt); end",
"def prompt_and_get_input_from_user\n prompt_user\n input = $stdin.readline.strip\nend",
"def interactive_menu\n loop do\n #print the menu and ask the user what to do\n print_menu\n #read the input and save it into a variable\n selection = STDIN.gets.chomp\n #do what the user has asked\n process(selection)\n end\n end",
"def text_input(method, options)\n basic_input_helper(:text_area, :text, method, options)\n end",
"def text_input(method, options)\n basic_input_helper(:text_area, :text, method, options)\n end",
"def prompt(text)\n @output += %(#{text}\\n)\n print text\n STDIN.gets\n end",
"def interactive_menu\n loop do\n print_menu\n process_menu(STDIN.gets.chomp)\n end\nend",
"def interactive_parser ( )\n puts 'Press <Enter> to exit...'\n #\n # Цикл обработки ввода.\n loop {\n\tstr = interactive_input( )\n\tbreak if str == \"\"\n\t#\n\t# Цикл посимвольной классификаци.\n\tstr.bytes.each do |c|\n\t parse( c.chr )\n\t puts 'parser: ' + @parserstate\n\t puts 'symbol: ' + interactive_output( c.chr ).to_s\n\t puts 'buffer: ' + @buffer.to_s\n\t puts 'state: ' + @chain.last.statename\n\t puts\n\tend\n }\n end",
"def interact\n log.info('Switching to interactive mode')\n $stdout.write(@buffer.get)\n until io_out.closed?\n rs, = IO.select([$stdin, io_out])\n if rs.include?($stdin)\n s = $stdin.readpartial(BUFSIZE)\n write(s)\n end\n if rs.include?(io_out)\n s = recv\n $stdout.write(s)\n end\n end\n rescue ::Pwnlib::Errors::EndOfTubeError\n log.info('Got EOF in interactive mode')\n end",
"def get_input\n story = gets.chomp\nend",
"def update_inputs\n if (text = Input.get_text)\n update_name(text.chars)\n return false\n end\n return joypad_update_inputs && true\n end",
"def interactive_menu\n loop do\n print_menu\n user_choice(STDIN.gets.chomp)\n end\nend",
"def pressKey\n STDIN.echo = false\n STDIN.raw!\n input = STDIN.getc.chr\n if input == \"\\e\" then\n input << STDIN.read_nonblock(3) rescue nil\n input << STDIN.read_nonblock(2) rescue nil\n end\nensure\n STDIN.echo = true\n STDIN.cooked!\n return input\nend",
"def ask_for(detail)\n puts \"Enter #{detail}\"\n STDIN.gets.chomp \nend",
"def text_area; end",
"def input(thing)\n print \"Enter #{thing}: \"\n gets.chomp\nend",
"def get_text(caption, prompt, options = {})\n Qt::InputDialog.getText(options[:parent], caption, prompt,\n options[:mode] || Qt::LineEdit::Normal,\n options[:text] || '')\n end",
"def text_field; end",
"def get_input\n @input = gets.chomp\n end",
"def interactive\n puts \"\\nEnter the method name you want to look up.\"\n\n if defined? Readline then\n Readline.completion_proc = method :complete\n puts \"You can use tab to autocomplete.\"\n end\n\n puts \"Enter a blank line to exit.\\n\\n\"\n\n loop do\n name = if defined? Readline then\n Readline.readline \">> \"\n else\n print \">> \"\n $stdin.gets\n end\n\n return if name.nil? or name.empty?\n\n begin\n display_name expand_name(name.strip)\n rescue NotFoundError => e\n puts e.message\n end\n end\n\n rescue Interrupt\n exit\n end",
"def input( message )\n selection = nil\n\n print message\n until yield(selection = gets.strip)\n print message\n end\n\n selection\n end",
"def get_keyboard_input\n c = read_char\n\n case c\n # when \" \"\n # \"SPACE\"\n # when \"\\t\"\n # :query\n when \"\\r\"\n :error\n # when \"\\n\"\n # \"LINE FEED\"\n when \"\\e\"\n :abort\n # when \"\\e[A\"\n # \"UP ARROW\"\n # :error\n # when \"\\e[B\"\n # \"DOWN ARROW\"\n # :error\n when \"\\e[C\"\n \"RIGHT ARROW\"\n :right\n when \"\\e[D\"\n \"LEFT ARROW\"\n :left\n when \"\\177\"\n :backspace\n when \"\\004\"\n :delete\n when \"\\e[3~\"\n :delete\n # when \"\\u0003\"\n # \"CONTROL-C\"\n # exit 0\n when /^.$/\n c\n else\n :error\n end\n end",
"def input\n if raw_mode?\n keys = console.getch\n if keys.ord == 27\n keys << console.read_nonblock(3) rescue nil\n keys << console.read_nonblock(2) rescue nil\n end\n keys\n\n else\n console.gets.chomp\n\n end\n end",
"def input; end",
"def input; end",
"def input; end",
"def input\n # If the mouse was lifted this tick\n if inputs.mouse.up\n # Set current input to none\n state.user_input = :none\n end\n\n # If the mouse was clicked this tick\n if inputs.mouse.down\n # Determine what the user is editing and edit the state.user_input variable\n determine_input\n end\n\n # Process user input based on user_input variable and current mouse position\n process_input\n end",
"def input; @input; end",
"def input; @input; end",
"def stdin; @current[1]; end",
"def stdin; @current[1]; end",
"def get_input\n #Get input from the user\nend",
"def prompt\n gets.strip\nend",
"def prompt(text)\n puts \">> \" + text\nend",
"def get_user_input\n user_input_valid gets.chomp\n end"
] |
[
"0.76246625",
"0.74624574",
"0.7382206",
"0.6982409",
"0.6885963",
"0.6794125",
"0.66711104",
"0.65774745",
"0.65194875",
"0.63821846",
"0.6378466",
"0.636011",
"0.63496083",
"0.63191146",
"0.631329",
"0.6285517",
"0.6285517",
"0.6268257",
"0.626699",
"0.622998",
"0.6228624",
"0.6220556",
"0.6218597",
"0.6211959",
"0.61976945",
"0.6194561",
"0.618989",
"0.6187601",
"0.6161834",
"0.615773",
"0.6155115",
"0.6154223",
"0.6147302",
"0.6117004",
"0.6115585",
"0.61112076",
"0.60727",
"0.60720706",
"0.607166",
"0.607166",
"0.607166",
"0.607166",
"0.607166",
"0.607166",
"0.607166",
"0.60616875",
"0.60497826",
"0.6043213",
"0.6030814",
"0.60299027",
"0.60296494",
"0.60227954",
"0.6014052",
"0.6011309",
"0.6011309",
"0.59747565",
"0.59745914",
"0.5973742",
"0.59736323",
"0.5972599",
"0.5970524",
"0.5965305",
"0.59635305",
"0.59572756",
"0.59421194",
"0.59412235",
"0.5937287",
"0.59214664",
"0.5921117",
"0.5921117",
"0.5919598",
"0.5915829",
"0.59131616",
"0.58920354",
"0.5890321",
"0.5889773",
"0.5884649",
"0.588263",
"0.5881968",
"0.58768266",
"0.5865319",
"0.5860415",
"0.585974",
"0.58588594",
"0.5858522",
"0.585788",
"0.585682",
"0.58543223",
"0.5835806",
"0.5835806",
"0.5835806",
"0.58311784",
"0.58302605",
"0.58302605",
"0.5828817",
"0.5828817",
"0.58284056",
"0.5816511",
"0.58103323",
"0.58086556"
] |
0.5919666
|
70
|
def feature_injection(array, &b) list = [:_] yield &b end FEATURE TERMS
|
def feature_set(*args, &b)
describe(*args, &b)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def feature(name, &block); begin; yield; features << name; rescue Exception; end; end",
"def use(*features); end",
"def append_features(mod) end",
"def [](*arg)\n @features[*arg]\n end",
"def list_features *args\r\n puts \"not implemented yet\"\r\n end",
"def each_feature\n self.each do |element|\n element.each_feature do |feat|\n yield @feature_instance_class.new(element,feat)\n end\n end\n end",
"def visit_array(h); end",
"def features\n []\n end",
"def __splat(x) end",
"def f6; return *['a','b'] &['a','Y','Z'] end",
"def features\n []\n end",
"def feature_args(ci_gcc_config)\n return [] if ci_gcc_config[:features].nil?\n\n ci_gcc_config[:features].map { |f| \"-f#{f}\" }\n end",
"def add_feature(feature)\n @features ||= []\n @features << feature\n end",
"def with_extracted_values(arr)\n str, vals = extract_values(arr)\n str = yield str\n inject_values(str, vals)\n end",
"def get_required_features(features)\n end",
"def super_fizzbuzz(array)\n\n\nend",
"def define_features\n @fvs.each do |vector, label|\n vector.each do |term, value|\n @features.add(term)\n end\n end\n end",
"def |(parslet); end",
"def |(parslet); end",
"def add!(*args)\n args.map {|a| features.add a.to_sym }\n self\n end",
"def features\n features = {}\n sexp_newtype_block.each do |s|\n if s[0] == :command and\n s[1][0..1] == [:@ident, \"feature\"] and\n s[2][0] == :args_add_block\n\n name = s[2][1][0][1][1][1]\n desc = s[2][1][1][1][1][1]\n\n features[name] = desc\n end\n end\n\n features\n end",
"def on_array(*body)\n @last_sexp =\n super(*body).tap do |sexp|\n next unless SPECIAL_LITERALS.include?(body.dig(0, :type))\n\n comments = sexp.dig(:body, 0).delete(:comments)\n sexp.merge!(comments: comments) if comments\n end\n end",
"def pass_block(arr)\n yield arr\nend",
"def to_tags\n arr = split_tags.map(&:add_at)\n if block_given?\n yield arr\n else\n arr\n end\n end",
"def >>(*args)\n args.to_a.flatten.each do |feature|\n features.delete feature.to_sym\n end\n self\n end",
"def functionalise(a)\n\n a.map do |x|\n\n if x =~ /\\w+\\[/ then\n epath, predicate = x.match(/^([^\\[]+)\\[([^\\]]+)\\]/).captures\n epath.split('/').map {|e| [:select, e]} + [:predicate, predicate]\n elsif x =~ /\\|/\n [:union] \n elsif x =~ /\\w+\\(/\n [x.chop.to_sym]\n elsif x =~ /\\d+/\n [:index, x[1..-2]]\n elsif x =~ /[\\w\\/]+/\n x.split('/').map {|e| [:select, e]}\n elsif x.is_a? Array\n functionalise(x)\n end\n \n end\n\n end",
"def append_features( hooked_instance )\n \n original_append_features( hooked_instance )\n super if defined?( super )\n \n end",
"def add_feature(feature)\n return unless feature\n\n @features ||= []\n @features << feature\n end",
"def & arg\n IterableArray.new(@array & arg.to_a)\n end",
"def elements; @feature['elements'] ||= [] end",
"def each &b\n\t\t@array.each(&b)\n\tend",
"def create_features_ensembl_seq_obj(bioseq,targets)\r\n targets.each do |key,value|\r\n f1 = Bio::Feature.new(\"target_CTTCTT\",\"#{key[0]}..#{key[1]}\")\r\n #im no sure if it is a interior coding exon \r\n f1.append(Bio::Feature::Qualifier.new('interior coding exon', \"#{value[0]}\"))\r\n f1.append(Bio::Feature::Qualifier.new('strand', \"#{value[1]}\"))\r\n bioseq.features << f1\r\n end\r\nend",
"def funify(array)\n\tarray << \"fun\"\n\t\nend",
"def each_subfeature(arg = nil)\n @subfeatures.each do |x|\n next if arg and x.feature != arg\n yield x\n end\n end",
"def |(arr)\n raise 'Not Implemented'\n end",
"def btest2() yield [1, 2] end",
"def multiply_els(_array = false)\n my_inject(:*)\n end",
"def loaded_features; end",
"def hello(array)\n i = 0\n collection = []\n while i < array.length\n collection << yield(array[i])\n i += 1\n end\n collection\nend",
"def hello(array)\n i = 0\n collection = []\n while i < array.length\n collection << yield(array[i])\n i += 1\n end\n collection\nend",
"def hello(array)\n i = 0\n collection = []\n while i < array.length\n collection << yield(array[i])\n i += 1\n end\n collection\nend",
"def mutliplied(array)\nend",
"def super_fizzbuzz(array)\n\tarray.map! {|i|\n\t\tif i % 3 == 0 && i % 5 == 0\n\t\t\ti = \"FizzBuzz\"\n\t\telsif i % 3 == 0\n\t\t\ti = \"Fizz\"\n\t\telsif i % 5 == 0\n\t\t\ti = \"Buzz\"\n\t\telse i = i\n\t\tend\n\t\t}\t\t\n\treturn array\nend",
"def super_fizzbuzz(array)\n\tarray.map! do |num|\n\t\tif num % 15 == 0\n\t\t\t\"FizzBuzz\"\n\t\telsif num % 3 == 0\n\t\t\t\"Fizz\"\n\t\telsif num % 5 == 0\n\t\t\t\"Buzz\"\n\t\telse\n\t\t\tnum\n\t\tend\n\tend\nreturn array\t\t\nend",
"def has_feature?(*)\n end",
"def feature_vector\n out = []\n field_names.each { |f| out << @profile[f] }\n out\n end",
"def my_collect(array) # put argument(s) here\n # code here\n i = 0\n result = []\n\n while i < array.size\n\n result << yield(array[i])\n i += 1\n end\nresult\nend",
"def each(arg = nil)\n @features.each do |x|\n next if arg and x.feature != arg\n yield x\n end\n end",
"def _lex_indicies=(_arg0); end",
"def _lex_indicies=(_arg0); end",
"def _lex_indicies=(_arg0); end",
"def _lex_indicies=(_arg0); end",
"def activate_(u_ary)\n u_ary.map { |u| @f_[u] }\n end",
"def generate_feature_vector probs\n (0..7).map do |i|\n ::DistSampler.new({ true => probs[i], false => (1 - probs[i]) }).sample\n end\n end",
"def super_fizzbuzz(array)\n\narray.map! { |element| \n if(element % 15 == 0) \n \"FizzBuzz\" \n elsif (element % 3 == 0) \n \"Fizz\" \n elsif (element % 5 == 0) \n \"Buzz\" \n else \n element \n end\n}\n\np array\n\nend",
"def enumerator\n [@feature]\n end",
"def before_feature_element(feature_element)\n @in_feature_element = true\n @current_feature[:elements] = [] if @current_feature[:elements].nil?\n @current_feature_element = {}\n @current_feature[:elements] << @current_feature_element\n end",
"def splat_mth(*mult_arg)\n p mult_arg #it's array :) !\n p mult_arg.class\n p mult_arg.object_id\n mult_arg.map {|arg| }\n end",
"def my_map_mod(&proc)\n array = []\n self.my_each do |item|\n array << proc.call(item)\n end\n array\n end",
"def extract_argument_lists(args, splittable_args); end",
"def flag()\n\tb=[0,0.2,0.6]\n\ty=[0.8,0.8,0.2]\n\tr=[1,0,0]\n\t\n\t[[b,b,y,y,r,r],\n\t[b,b,y,y,r,r],\n\t[b,b,y,y,r,r],\n\t[b,b,y,y,r,r],\n\t[b,b,y,y,r,r]]\nend",
"def generalise_feature(landmark_index, feature_index=0)\n feature=self.landmarks[landmark_index][feature_index]\n alternates=[]\n Wildcards.matching(feature) do |wildcard|\n r=self.deep_clone\n r.landmarks[landmark_index][feature_index]=wildcard\n alternates << r\n yield r if block_given?\n end\n return alternates\n end",
"def add_loaded_features(loaded_features); end",
"def bulk_tweet_shortener(array)\t\n\t array.map {|a| puts word_substituter(a)}\nend",
"def enable_features(feature_names)\n self.enabled_features = feature_names\n end",
"def many &blk\r\n build_piece AnyNumber, blk\r\n end",
"def mappa_e_compatta(&block)\n self.map.with_index(&block).compact\n end",
"def scan_ff_for_tag feature\n if feature[:gherkin][\"tags\"]\n feature[:gherkin][\"tags\"].each do |tag|\n if tag[\"name\"] == Observer.tag\n f = feature.clone\n @@tag_features << f\n @num = false\n puts \"\"\n end\n end\n end\n end",
"def <<(feature)\n @features << feature\n end",
"def guard_with(*features, &block)\n yield if block_given? && features.any? {|f| feature_enabled?(f)}\n end",
"def lcts(array)\nend",
"def iterate_with_proc_example!(&code)\n\t\tself.each_with_index do |n, i|\n\t\t\tself[i] = code.call(n)\n\t\tend\n\tend",
"def bulk_tweet_shortener(array)\n array.collect do |tweet|\n puts word_substituter(tweet)\n end\nend",
"def misc_features(code)\n \tanswer = Array.new\n if code.nil?\n self.seq_region.misc_features.each do |mf|\n if mf.seq_region_start > self.start and mf.seq_region_end < self.stop\n answer.push(mf)\n end\n end\n else\n self.seq_region.misc_features.each do |mf|\n if mf.misc_sets[0].code == code\n if mf.seq_region_start > self.start and mf.seq_region_end < self.stop\n answer.push(mf)\n end\n end\n end\n end\n \treturn answer\n end",
"def super_fizzbuzz(array)\n array.map! {|variable|\n if variable % 15 == 0\n variable = \"FizzBuzz\"\n elsif variable % 5 == 0\n variable = \"Buzz\"\n elsif variable % 3 == 0\n variable = \"Fizz\"\n else\n variable = variable\n end\n }\n\n return array\n\nend",
"def all_features\r\n feature_objects.inject([]) {|r, obj| r + obj.features }\r\n end",
"def *(vector)\n end",
"def features_simple_real_modular(A=matrix)\n \n\nend",
"def mappa_e_appiattisci(&block)\n self.map.with_index(&block).flatten\n end",
"def super_fizzbuzz(array)\n\narray.map! do |e|\n if e % 15 == 0\n e = \"FizzBuzz\"\n elsif e % 3 == 0\n e = \"Fizz\"\n elsif e % 5 == 0\n e = \"Buzz\"\n else\n e\n end\n end\np array\n\nend",
"def super_fizzbuzz(array)\n\tarray.collect do |i|\n \tif i % 15 == 0\n \t\t\"FizzBuzz\"\n \telsif i % 5 == 0\n \t\t\"Buzz\"\n \telsif i % 3 == 0\n \t\t\"Fizz\"\n \telse\n \t\ti\n \tend\n \tend\nend",
"def ast\n feature(get_result) unless @feature\n @feature\n end",
"def my_map(array)\n new_array = []\n\n for element in array\n new_array.push yield element\n end\n\n new_array\n end",
"def test inputs\n inputs.collect &fann.method(:run)\n end",
"def explore_array(method, *arguments)\n ['a', 'b', 'c'].send(method, *arguments)\nend",
"def getArray _args\n \"getArray _args;\" \n end",
"def add_bang(array)\n\tarray.map {|string| string + \"!\"}\nend",
"def batch_badge_creator(array)\n new_array = array.map { |e| \"Hello, my name is #{e}.\" }\nend",
"def spy_array(x)\n #spy_repeater\n p real_entry\n p alias_entry\nend",
"def work_input(input_arr)\n yield(input_arr)\nend",
"def filters=(_arg0); end",
"def filters=(_arg0); end",
"def features\n @features ||= {}\n @features.keys\n end",
"def data_for_features(info, sep: nil)\n data = []\n\n info.each do |feature_name, associated_value|\n if has_feature?(feature_name.to_sym)\n if associated_value.respond_to?(:call)\n data << associated_value.call\n else\n data << associated_value\n end\n end\n end\n\n if data.length == 1\n def data.inspect\n first\n end\n elsif sep\n def data.inspect\n join(sep)\n end\n end\n\n data\n end",
"def my_array_splitting_method(source)\nend",
"def preprocess(&block); end",
"def for_each_in(array, &instructions)\n for i in 0...array.length\n instructions.call(array[i])\n end\nend",
"def each(options = {})\n options = { strand_order: false }.merge(options)\n \n # Sort the regions\n sorted_features = @features.sort\n sorted_features.reverse! if options[:strand_order] && @feature.reverse_strand?\n \n sorted_features.each { |feature| yield feature }\n end",
"def my_collect(words_array)\n counter = 0\n new_array = [] # this is the array we will push it into\n # grab (iterate through) each item in that array\n while counter < words_array.length\n# push the result of that action into a new array\n new_array << yield(words_array[counter])\n counter += 1\n end\n new_array\nend",
"def misc_features(code)\r\n \tanswer = Array.new\r\n if code.nil?\r\n self.seq_region.misc_features.each do |mf|\r\n if mf.seq_region_start > self.start and mf.seq_region_end < self.stop\r\n answer.push(mf)\r\n end\r\n end\r\n else\r\n self.seq_region.misc_features.each do |mf|\r\n if mf.misc_sets[0].code == code\r\n if mf.seq_region_start > self.start and mf.seq_region_end < self.stop\r\n answer.push(mf)\r\n end\r\n end\r\n end\r\n end\r\n \treturn answer\r\n end"
] |
[
"0.6573996",
"0.63501793",
"0.6236588",
"0.58633983",
"0.5725453",
"0.5616294",
"0.55136245",
"0.54750067",
"0.5455767",
"0.5388028",
"0.5383501",
"0.5331738",
"0.5329942",
"0.53293324",
"0.5319823",
"0.52926487",
"0.52900153",
"0.5285923",
"0.5285923",
"0.5276875",
"0.5275268",
"0.5266422",
"0.5263456",
"0.5258731",
"0.52560216",
"0.52456594",
"0.5243775",
"0.52290916",
"0.5228782",
"0.52193403",
"0.52106583",
"0.51934206",
"0.519334",
"0.51899546",
"0.5186714",
"0.5178668",
"0.5175542",
"0.516664",
"0.51361287",
"0.51361287",
"0.51361287",
"0.51324105",
"0.51240236",
"0.51153445",
"0.51103234",
"0.5107068",
"0.5101659",
"0.5101143",
"0.5098239",
"0.5098239",
"0.5098239",
"0.5098239",
"0.50959235",
"0.508566",
"0.5085429",
"0.50789165",
"0.50748223",
"0.50740707",
"0.5066952",
"0.5062555",
"0.50486916",
"0.50414795",
"0.50288904",
"0.5027415",
"0.50252074",
"0.50244474",
"0.5017121",
"0.5015908",
"0.5014574",
"0.5012819",
"0.50096506",
"0.49953666",
"0.49865067",
"0.4974893",
"0.4974883",
"0.49704728",
"0.49634302",
"0.49631858",
"0.49515513",
"0.49454635",
"0.49434617",
"0.49424335",
"0.4942245",
"0.49365017",
"0.49317527",
"0.49304667",
"0.49220538",
"0.49215674",
"0.4921194",
"0.4918439",
"0.4914246",
"0.4914246",
"0.49137223",
"0.49111614",
"0.49087566",
"0.49063617",
"0.49044293",
"0.49021932",
"0.49003002",
"0.48937884"
] |
0.57449955
|
4
|
AGILE TERMS def epic(args, &b) describe(args, &b) end def story(args, &b) describe(args, &b) end WWW
|
def feature_www(s, options={}, &b)
s = ["Feature:", s, www(options)]
feature(s, &b)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def help\n\tusage\n\tputs \"This tool is oriented to separate web pages into segments called blocks, based on the structural and visual properties\"\nend",
"def learn_it\n interviews = \"https://www.youtube.com/playlist?list=PLUJNJAesbJGVGDiZJ8WvcEC3e1O5cDb5r\"\n puts \"If you want to learn from the IT pros, check out this playlist #{interviews}\"\n superprof_it = \"http://bit.ly/superprof-info\"\n puts \"If you want private lessons, checkout my profile here: #{superprof_it}\"\n podia\nend",
"def desc\n\t\t\"Useful for analyzing scanned web sites later.\"\n\tend",
"def help; end",
"def help; end",
"def help; end",
"def introduction\r\n\r\n end",
"def help\n \n end",
"def tutorial\n puts\n rules\n deck = Visualized.new\n examples deck.base_deck\n bad_examples deck.base_deck\nend",
"def how_it_works\r\n end",
"def description\n \"This task runs a web scan and adds webpages with interesting contents\"\nend",
"def help\r\n end",
"def help\r\n end",
"def about; end",
"def about; end",
"def blogs_weblog_explain; \"List your weblogs.\"; end",
"def help\n end",
"def help\n end",
"def help\n end",
"def help\n end",
"def help\n end",
"def help\n end",
"def help\n end",
"def help\n end",
"def help\n\nend",
"def examples_page\n Format.usage('This is my examples page, I\\'ll show you a few examples of how to get me to do what you want.')\n Format.usage('Running me with a file: whitewidow.rb -f <path/to/file> keep the file inside of one of my directories.')\n Format.usage('Running me default, if you don\\'t want to use a file, because you don\\'t think I can handle it, or for whatever reason, you can run me default by passing the Default flag: whitewidow.rb -d this will allow me to scrape Google for some SQL vuln sites, no guarentees though!')\n Format.usage('Running me with my Help flag will show you all options an explanation of what they do and how to use them')\n Format.usage('Running me without a flag will show you the usage page. Not descriptive at all but gets the point across')\nend",
"def description\n \"This takes a screenshot of a website using webdriver\"\nend",
"def describe(title=nil, id=nil)\n puts \"In development...\"\n end",
"def gen_usage\n puts 'Usage:'\n puts ' poole [ACTION] [ARG]'\n puts ''\n puts 'Actions:'\n puts ' draft Create a new draft in _drafts with title SLUG'\n puts ' post Create a new timestamped post in _posts with title SLUG'\n puts ' publish Publish the draft with SLUG, timestamping appropriately'\n puts ' unpublish Move a post to _drafts, untimestamping appropriately'\n exit\n end",
"def index\n @urls = ['index', 'fade_replace', 'simple_blind_ror', 'javascript']\n @descriptions = {'index' => \"listing of all demos/methods. This page\",\n \n 'fade_replace' => \"link triggers central page replacement. This will be used in the final project. Uses ror/rjs\",\n 'simple_blind_ror' => \"simplistic scriptaculous effects using ror. demo only.\",\n 'javascript' => \"uses javascript directly. demo only. straight from Scriptaculous site.\"\n }\n end",
"def tutorial\n end",
"def wagner; end",
"def learn_math\n puts \"If you need some basic maths lessons.\"\n prglump = \"https://www.youtube.com/channel/UCLxVJHhqaLMuyTcbUsoCrFg/videos?view=0&sort=p&flow=grid\"\n puts \"Perhaps you can learn something on this YouTube channel #{prglump}\"\n superprof_math = \"https://bit.ly/2wlBbF9\"\n puts \"If you want more advance math private lessons, checkout my profile here: #{superprof_math}\"\n podia\nend",
"def story_time(thing1, thing2)\n puts \"This is a short story of #{thing1} and #{thing2}. The end.\"\nend",
"def description\n \"This task grabs the robots.txt and adds each line as a web page\"\nend",
"def help_message\n make_response %(*Usage:*\n\n To get stats about all players:\n `foosey stats`\n\n To do anything else:\n http://foosey.futbol)\nend",
"def learn_english\n puts \"Go learn English!\"\n dyse = \"https://doyouspeakenglish.fr/\"\n puts \"If you're French, go there for FREE: #{dyse}\"\n english_kit = \"http://bit.ly/kit-anglais\"\n puts \"And for only 1€ you can get a complete starter kit here: #{english_kit}\"\n grammar = \"https://learnenglish.britishcouncil.org/skills\"\n puts \"Otherwise go there: #{grammar}\"\n superprof_english = \"http://bit.ly/superprof-anglais\"\n puts \"If you want private lessons, checkout my profile here: #{superprof_english}\"\n podia\nend",
"def main\n test_url = \"http://eatsblog.guidelive.com/archives/2007/06/you-know-you-want-it.html\"\n parse(test_url)\n end",
"def desc\n\t\t\t\"XSS Framework managing XSS modules\"\n\t\tend",
"def ⚘ *args\n href, *title = args.flatten\n title = title.join(SEPARATOR).strip\n harvest __callee__, %Q(\n<figure>\n <img src='#{href.unbowl}'/>\n <figcaption>\n <p>#{title}</p>\n </figcaption>\n</figure>\n)\n end",
"def druby_weblog_explain; \"Start the DRuby daemon for weblogs in your config.\"; end",
"def about\n \n end",
"def robots; end",
"def robots; end",
"def create_weblog_explain; \"Create a brand new weblog.\"; end",
"def help\n\tputs \"Things a baby adventurer needs to know : \"\n\tputs \"(g)o (direction): (n,w,e,s) move that direction\"\n\tputs \"(o)pen: open doors, chests, your eyes, etc\"\n\tputs \"(l)ook: examine the room your in\"\n\tputs \"(t)ake: add an item to your inventory\"\n\tputs \"(u)se: use an item in your inventory\"\n\tputs \"(i)nventory: see what items you have\"\n\tputs \"(q)uit: quit the game, as a coward would.\"\nend",
"def about\n # STUB\n end",
"def full_story\n puts \" This is your user story\".colorize(:color => :yellow)\n\n puts \"\n I walk through the color jungle. I take out my\n #{@adjective} canteen. There's a #{@adjective2} parrot with \n a #{@adjective3} #{@noun} in his mouth right\n there in front of me in the #{@adjective4}\n trees! I gaze at his #{@adjective5} #{@noun2}. A sudden \n sound awakes me from my daydream! A panther’s #{@verb} \n in front of my head! I #{@verb2} his #{@adjective6} \n breath. I remember I have a packet of #{@noun3} that \n makes go into a deep slumber! I #{@verb3} it away from me \n in front of the #{@noun3}. Yes he's eating it! I #{@verb4}\n away through the #{@adjective7} jungle. I meet my parents \n at the tent. Phew! It’s been an exciting day \n in the jungle.\"\n\n\n end",
"def description\n\t\"This task scrapes Hoovers for company info.\"\nend",
"def introduction\n puts 'hello welcome to the github scrapper'.light_blue\n puts 'this tool is desgined for fetching data from github quickly and saving it to a csv file'.light_blue\nend",
"def intro()\n show do\n title \"Fragment analyzing info\"\n note \"In this protocol, you will do the following:\"\n note \"- gather stripwells of fragments\"\n note \"- organize them in the fragment analyzer machine\"\n note \"- set up and run the analyzer\"\n note \"- upload the analysis results to Aquarium\"\n end\n end",
"def desc\n\t\t\"Basic I/O\"\n\tend",
"def help\n puts \"usage: #{@script} --site [URL]\"\n puts\n puts \" --site the site name to save the site\"\nend",
"def does\n puts \"ALL THE THINGESSSS!!!eleventy\"\nend",
"def about\r\n end",
"def headline; end",
"def do_usage()\n puts \"Usage: gamera_dir [flags] server directory\"\n puts \"Import gamera OCR for book into specified TypeWright server from given directory.\"\n puts \"If book does not already exist, issue error.\"\n puts \" -v Verbose output\"\n puts \" -t Test only -- don't actually upload files\"\nend",
"def elearning\n @title = \"e-Learning\"\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def about\n end",
"def description\n description = puts \"Shelves containing food and other common supplies line the walls \"\\\n \"here. These things were probably stolen from the local village or nearby farms during \"\\\n \"raids. Although there doesn't seem to be anything of value here, you never know what a \"\\\n \"search will turn up.\"\n puts \"You can go back the way you came from.\"\n if @monster\n puts \"An evil #{@monster.monster} is here, ruffling for something to eat.\"\n else\n puts \"The squeek of a rat and pitter-patter of tiny rodent feet is all you hear.\"\n end\n end",
"def describe function\n\t\t\tYARD::Registry.load!(YARD::Registry.yardoc_file_for_gem('sense'))\n\t\t\tdoc = YARD::Registry[\"#{self.class}##{function}\"]\n\t\t\treturn nil unless doc\n\t\t\tdescr = \"\\n#{doc.name(true)}(#{doc.tags(:param).inject([]){|a,p| a.push(p.name)}.join(\" \")}) : #{doc.docstring}\\n\\n\"\n\t\t\tif doc.has_tag?(:param)\n\t\t\t\tdescr << \"Parameters :\\n\"\n\t\t\t\tdoc.tags(:param).each do |parameter|\n\t\t\t\t\tdescr << \"(#{parameter.types.join(\", \")}) #{parameter.name} - #{parameter.text}\\n\"\n\t\t\t\tend\n\t\t\t\tdescr << \"\\n\"\n\t\t\tend\n\t\t\tif doc.has_tag?(:option)\n\t\t\t\toptions = doc.tags(:option)\n\t\t\t\tdescr << \"Customizable Hash of options \\\"#{options[0].name}\\\"\\n\"\n\t\t\t\toptions.each do |option|\n\t\t\t\t\tdescr << \"(#{option.pair.types.join(\", \")}) #{option.pair.name} - #{option.pair.text}\\n\"\n\t\t\t\tend\n\t\t\t\tdescr << \"\\n\"\n\t\t\tend\n\t\t\tdescr << \"\\n\"\n\t\tend",
"def desc\n\t\t\"Meterpreter\"\n\tend",
"def main(args)\n file, url = args\n if not url\n puts \"Missing URL\"\n return\n end\n\n\tlang, title = url =~ m{^https?://(\\w+)\\.wikipedia\\.org/wiki/(.*)$};\n\nend",
"def leech(target=nil,opt=nil,limit=nil)\n if not target\n # no target site provided, usage must be something like \"runleecher.rb [ sitename [update|save] [news_limit] ]\"\n puts \"(Fatal Error) No target site privided\\n\"\n else\n puts \"Leeching #{target.title} ...\\n#{target.url_target}\\n\\n\"\n #\n url = Regexp.new(target.regexp_url)\n date = Regexp.new(target.regexp_date) if target.regexp_date\n time = Regexp.new(target.regexp_time) if target.regexp_time\n title = Regexp.new(target.regexp_title)\n intro = Regexp.new(target.regexp_intro)\n #\n if res = retrieve_url(target.url_target)\n # url, title & intro are a must for leeched articles\n urls = res.body.scan(url)\n titles = res.body.scan(title)\n intros = res.body.scan(intro)\n dates = res.body.scan(date) if date\n times = res.body.scan(time) if time\n #\n if urls.empty?\n puts \"\\tError: No match at all. Time to update RexExps?\\n\"\n elsif urls.size == titles.size && titles.size == intros.size\n # update 'limit' stories: delete first 'limit' stories before inserting new\n if opt == 'update'\n if target.limit\n if target.limit == 0\n target.stories.destroy_all\n else\n target.stories[0..target.limit].each { |obj| obj.destroy }\n end\n elsif limit\n target.stories[0..limit].each { |obj| obj.destroy }\n end\n end\n # urls, titles & intros #'s match, process\n urls.each_with_index do |uri,i|\n break if (limit && limit.to_i==i) || (target.limit && target.limit!=0 && target.limit==i)\n #\n uri = strip_html(uri.to_s.strip)\n uri = (target.url_base + uri) if uri[0..6].downcase != 'http://' && target.url_base\n uri = (target.url_pre + uri) if target.url_pre\n uri = (uri + target.url_post) if target.url_post\n #\n yy, mm, dd = fix_date(dates[i]) if date\n hh, mn, ss = fix_time(times[i]) if time\n #\n if target.regexp_body\n if story = retrieve_url(uri)\n if target.is_not_multiline\n body = story.body.scan(Regexp.new(target.regexp_body))\n else\n # note forced multi-line regexp\n body = story.body.scan(Regexp.new(target.regexp_body,Regexp::MULTILINE))\n end\n if body.empty?\n # strange... got full text page && regexp, but no match found (maybe uri redirect?)\n # safe best guess: ignore this story\n ignore_story = 1\n else\n fix_body = body.to_s\n fix_body.gsub!(/\\s*(<br ?\\/?>\\s*){2,}/i,'<p>') # multiple <br>'s to <p>\n fix_body.gsub!(/\\n+/,'') # multiple newlines to nil\n fix_body = strip_html(fix_body,['p','br','a'])\n # date & time\n if target.regexp_body_date\n date = Regexp.new(target.regexp_body_date)\n dates = story.body.scan(date)\n yy, mm, dd = fix_date(dates[0])\n end\n if target.regexp_body_time\n time = Regexp.new(target.regexp_body_time)\n times = story.body.scan(time)\n hh, mn, ss = fix_time(times[0])\n end\n # story image\n if target.regexp_image\n image = story.body.scan(Regexp.new(target.regexp_image))\n if not image.empty?\n image_url = image.to_s\n image_url = (target.image_base ? target.image_base : target.url_base) + image_url if image_url[0..6].downcase != 'http://'\n end\n end\n end\n else\n # can't retrieve text uri\n end\n end\n #\n if ignore_story == 1\n puts \"Ignoring story for #{uri}, (no text match)\"\n else\n yy, mm, dd = fix_date(nil) unless (yy && mm && dd)\n hh, mn, ss = fix_time(nil) unless (hh && mn && ss)\n date_time = yy + '-' + mm + '-' + dd + ' ' + hh + ':' + mn + ':' + ss\n #\n fix_title = strip_html(titles[i].to_s)\n fix_title = (target.title_pre + fix_title) if target.title_pre\n fix_title = (fix_title + target.title_post) if target.title_post\n fix_intro = strip_html(intros[i].to_s)\n #\n dup = target.stories.size ? target.stories.find(:first, :conditions => [\"url = ?\", uri]) : nil\n if opt == :update || opt == :save\n if dup && opt == :save\n # check for duplicate entries\n puts \"Duplicate entry for #{uri}, skipping.\"\n else\n # save all new entries\n print \"Updating \" if opt == :update\n print \"Inserting \" if opt == :save\n puts \"#{uri} ...\"\n if body\n if image_url\n Story.create(:target_id => target.id, :title => fix_title, :url => uri, :time => date_time, :intro => fix_intro, :body => fix_body, :image_url => image_url)\n else\n Story.create(:target_id => target.id, :title => fix_title, :url => uri, :time => date_time, :intro => fix_intro, :body => fix_body)\n end\n else\n Story.create(:target_id => target.id, :title => fix_title, :url => uri, :time => date_time, :intro => fix_intro)\n end\n end\n else\n # just show new available entries, if any\n if dup\n puts \"Already stored entry for #{uri}\"\n else\n puts '*** NEW ENTRY ***'\n puts fix_title\n puts uri\n puts date_time\n puts fix_intro\n puts '---' if fix_body\n puts fix_body if fix_body\n puts '---' if image_url\n puts image_url if image_url\n end\n end\n end\n puts\n end\n else\n puts \"\\tError: Wrong URLs / Titles / Intros match.\"\n end\n else\n puts \"\\tError: Could not fetch page.\"\n end\n end\n end",
"def learning_help(m)\n m.reply \"Learning module\"\n m.reply \"===========\"\n m.reply \"Description: Teach the bot about things, and have it repeat that info back later.\"\n m.reply \"Usage: [botname] [thing] is [information] (to store additional [information] under the keyword [thing].)\"\n m.reply \"[botname] [thing] (to get whatever the bot knows about [thing].)\"\n end",
"def intro\n\tputs \"\\nHey, this is Grandma. HOW ARE YOU DEARY?\"\nend",
"def program_desc(desc)\n abstract!\n end",
"def help *error_msg\n puts error_msg if error_msg and not error_msg.empty?\n puts \"Usage: #{$0} <path to blog post>\"\n puts \"Loads all the images available in the blog post\"\n exit\nend",
"def desc; end",
"def add_weblog_explain; \"Adds a pre-existing hobix weblog to your list.\"; end",
"def about\n end",
"def app_about\n end",
"def describe\n # TODO\n end",
"def explain\n \n end",
"def about_us; end",
"def difficulty_intro\n print \"\\nWhat difficulty would you like to play? (e)asy, (m)edium, or (h)ard? \"\n end",
"def usage; end",
"def usage; end",
"def describe(description)\n api_desc(description)\n end",
"def learn_more\n end",
"def introduction\n show do\n title \"Fragment analyzing info\"\n note \"In this protocol, you will gather stripwells of fragments, organize them in the fragment analyzer machine, and upload the analysis results to Aquarium.\"\n end\n end",
"def about\n\tend",
"def about\n\tend"
] |
[
"0.65469486",
"0.6292197",
"0.62427884",
"0.60935664",
"0.60935664",
"0.60935664",
"0.6010507",
"0.5994045",
"0.596182",
"0.5891901",
"0.589163",
"0.5884729",
"0.5884729",
"0.5859082",
"0.5859082",
"0.58347964",
"0.5829574",
"0.5829574",
"0.5829574",
"0.5829574",
"0.5829574",
"0.5829574",
"0.5829574",
"0.58105934",
"0.5807683",
"0.5799527",
"0.57991165",
"0.5782087",
"0.57636493",
"0.57631874",
"0.5743498",
"0.5725393",
"0.5703461",
"0.56986296",
"0.56891924",
"0.566964",
"0.5648838",
"0.5646141",
"0.56443053",
"0.564215",
"0.56248015",
"0.56099945",
"0.55881417",
"0.55881417",
"0.55842435",
"0.55800885",
"0.5573888",
"0.5558263",
"0.554673",
"0.55438",
"0.55423856",
"0.55418414",
"0.55408186",
"0.5533521",
"0.55287874",
"0.55247396",
"0.55233705",
"0.5520638",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55137223",
"0.55066234",
"0.54966015",
"0.54835176",
"0.5466927",
"0.54622173",
"0.5460908",
"0.54568845",
"0.54562825",
"0.5450396",
"0.5448354",
"0.54250973",
"0.54250443",
"0.5423776",
"0.5418197",
"0.5413328",
"0.5406635",
"0.5406589",
"0.5399825",
"0.5399825",
"0.53975654",
"0.53966844",
"0.5394621",
"0.53913796",
"0.53913796"
] |
0.0
|
-1
|
Takes in lat and long coord of user and radius defaults to ipaddress location and 0.5
|
def index # returns all bikes within a certain radius
## TODO: use coordinates later, when more campuses and bikes.
# # defaults radius to half mile, and coordinate to requesting ip address
# radius = params[:radius] ? params[:radius] : 0.5
# coordinates = params[:coordinates] ? params[:coordinates] : request.location
# puts coordinates
# @bikes = Coordinate.near(coordinates, radius).joins(:bikes)
@bikes = Bike.available
render json: @bikes
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def search_radius\n exact_location ? 100 : 50_000\n end",
"def radius\n end",
"def withinRadius(latitude,longitiude,radius)\n \n rad = 3963.1676\n lat1 = to_rad(latitude.to_f)\n lat2 = to_rad(self.latitude.to_f)\n lon1 = to_rad(longitiude.to_f)\n lon2 = to_rad(self.longitude.to_f)\n dLat = lat2-lat1 \n dLon = lon2-lon1\n \n a = Math::sin(dLat/2) * Math::sin(dLat/2) +\n Math::cos(lat1) * Math::cos(lat2) * \n Math::sin(dLon/2) * Math::sin(dLon/2);\n \n c = 2 * Math::atan2(Math::sqrt(a), Math::sqrt(1-a));\n \n distance = rad * c\n \n #logger.debug \"distance IS\"\n #logger.debug distance\n #logger.debug \"radius IS\"\n #logger.debug radius\n \n return distance\n end",
"def in_range?(radius:, location:)\n (((location.latitude - @latitude) ** 2) + ((location.longitude - @longitude) ** 2)) < (radius ** 2)\n end",
"def within_radius(radius: nil, limit: 100)\n # 3959 if miles; 6271 if km\n lat = self.lat\n lng = self.lng\n q = User.select(\"*,\n ( 3959 * acos (\n cos ( radians(#{lat}) )\n * cos( radians( lat ) )\n * cos( radians( lng ) - radians(#{lng}) )\n + sin ( radians(#{lat}) )\n * sin( radians( lat ) )\n )) AS distance\").to_sql\n\n result = User.from(Arel.sql(\"(#{q}) AS users\")).\n where.not(id: self.id).\n order(distance: :desc).\n limit(limit)\n\n result = result.where('distance <= ?', radius) if radius\n result\n end",
"def nearby\n if current_user.lat\n dist = 1.5\n minlat = current_user.lat - dist\n maxlat = current_user.lat + dist\n minlon = current_user.lon - dist\n maxlon = current_user.lon + dist\n @users = DrupalUsers.find(:all, :conditions => [\"lat != 0.0 AND lon != 0.0 AND lat > ? AND lat < ? AND lon > ? AND lon < ?\",minlat,maxlat,minlon,maxlon])\n end\n end",
"def spatial_query(bounds)\n sb = bounds_to_center_radius(bounds)\n if sb.present?\n \"{!spatial lat=#{sb[:center][:latitude]} long=#{sb[:center][:longitude]} radius=#{sb[:radius]} unit=km calc=arc threadCount=2}\"\n else\n \"\"\n end\n end",
"def radius(row)\n return nil if row.obs_lat.present?\n\n r1 = lat_radius(row)\n r2 = long_radius(row)\n return nil if !r1 || !r2\n\n [r1, r2].max.to_f.round\n end",
"def in_radius?(lat, lng, distance = nil)\n return false unless ([lat,lng].all? && (radius.present? || distance.present?))\n distance_from([lat,lng], :km) <= ( distance ? distance : radius )\n end",
"def geocode(latitude, longitude, radius = 50)\n raise InvalidGeocodinates unless (-90 <= latitude && latitude <= 90 && -180 <= longitude && longitude <= 180)\n @query[:latitude] = latitude\n @query[:longitude] = longitude\n @query[:radius] = radius\n return self\n end",
"def inradius\n @inradius ||= 2 * self.area / self.perimeter\n end",
"def base_radius\n 200\n end",
"def calculate_circle_area(radius)\nend",
"def calculate_circle_area(radius)\nend",
"def initialize(radius)\n @radius = radius\n end",
"def c_radius \n Math.sqrt((@x*@x)+(@y*@y))\n end",
"def coordinate_bounds(latitude, longitude, radius)\n radius = radius.to_f\n factor = (Math::cos(latitude * Math::PI / 180.0) * 69.0).abs\n [\n latitude - (radius / 69.0),\n latitude + (radius / 69.0),\n longitude - (radius / factor),\n longitude + (radius / factor)\n ]\n end",
"def validate_radius(params, default = \"\")\n return default unless params[:radius]\n return validate_positive_integer(params[:radius])\n end",
"def initialize(radius)\n @radius = radius\n end",
"def radius\n RANDOM_RADIUS / 111300\n end",
"def is_nearby?(user_lat, user_long, bus_lat, bus_long)\n Math.hypot((user_lat - bus_lat), (user_long - bus_long)) <= .01\n end",
"def set_user_location\n return unless (search_params[:lat] && search_params[:long]) ||\n search_params[:zip_code]\n\n user_location_object(search_params[:lat], search_params[:long],\n search_params[:zip_code])\n end",
"def nearby\n\n params[:distance] ||= 20\n\n # Use the current user's IP address to retrieve the user coordinates\n @user_coordinates = Geocoder.coordinates(request.remote_ip)\n\n # Presume geolocation will fail\n @geocoder_success = false\n\n # If geolocation fails, use a default of downtown Columbus\n if @user_coordinates == [0.0, 0.0]\n\n # Default coordinates when can't geolocate the current user\n @user_coordinates = [39.961122, -83.000431]\n\n else\n\n @geocoder_success = true\n\n end\n\n @locations = Location.near(@user_coordinates, params[:distance]) #.paginate(:page => params[:page], :per_page => 10)\n\n end",
"def surrounding(position, radius)\n dlat = 0.0001\n dlng = 0.0001\n (1..radius).map do |r|\n (-r..r).map do |rlat|\n points = [sum(position, [dlat * rlat, dlng * (r - rlat.abs)])]\n if rlat.abs != r\n points += [sum(position, [dlat * rlat, dlng * (rlat.abs - r)])]\n end\n points\n end.flatten(1)\n end\nend",
"def max_radius\n 4000\n end",
"def ensure_params_have_values\n @attributes[:lat] = 33.1243208 unless @attributes[:lat].present? \n @attributes[:lon] = -117.32582479999996 unless @attributes[:lon].present? \n @attributes[:radius].present? ? @_search_radius = @attributes[:radius] : self.set_radius\n end",
"def georadius(*args, **geoptions); end",
"def location_format_gnip\n unless @lat.nil? || @long.nil? || @radius.nil?\n location = \"point_radius:[#{@long} #{@lat} #{@radius}]\"\n # prepend space for the rule if hashtags have been set\n location.prepend(\" \") if @hashtags.any?\n location\n else\n ''\n end\n end",
"def getStationNearest\n coordinate_lat = params[:lattitude].to_f\n coordinate_lng = params[:longtitude].to_f\n distance_input = params[:distance].to_f\n end",
"def radius=(r); @@R = r; end",
"def is_nearby(user_latitude,user_longitude, bus_latitude, bus_longitude)\n (user_longitude - bus_longitude).abs <= 0.01 && (user_latitude - bus_latitude).abs \nend",
"def areas_by_radius(lat, lon, radius_meters)\n #get min/max latitude and longitude of radius around point\n min_lat, min_lon, max_lat, max_lon = radius_box = bounding_box(lat, lon, radius_meters)\n\n #estimate the size of boxes to target\n steps = estimate_steps_by_radius(radius_meters)\n #re-encode point using steps\n #the geohashes are composed of 32 distinct numbers/letters, basically base 32\n #bits are composed of 1s and 0s, base 2 or binary\n #steps is the length of the binary number for longitude and latitude, and the combined length of the binary string (which interleaves both the longitude and latitude) is 2*steps\n # since 32 is 2^5, while 2 is 2^1, the length of a base 32 number will be the length of a binary number divided by 5 and plus 1 (32 base 10 = 10000 base 2 = 10 base 32).\n str_len = steps*2/5 + 1\n hash = encode(lat, lon, str_len)\n\n #get neighbors of box\n neighbors = neighbors(hash)\n neighbors_neighbors = neighbors.each_with_object([]) {|neighbor, nb| nb << neighbors(neighbor)}\n\n # 25 geohashes surrounding the original\n nb = neighbors_neighbors.flatten.uniq\n\n # remove those geohashes that are outside the bounding box\n nb.each do |neighbor|\n n_latlng_low, n_latlng_high = decode(neighbor)\n if n_latlng_low[0] > max_lat or n_latlng_low[1] > max_lon or n_latlng_high[0] < min_lat or n_latlng_high[1] < min_lon\n nb -= [neighbor]\n end\n end\n\n #return remaining neighbor list\n nb\n end",
"def process_geo\n\t if !params[:geo].nil? && params[:geo].split(\",\").length == 2\n\t\t@lat = params[:geo].split(\",\")[0].to_f\n\t\t@lng = params[:geo].split(\",\")[1].to_f\n\t end\n\t if params[:radius].nil?\n\t\t@radius = 1.0\n\t else\n\t\t@radius = params[:radius].to_f\n\t end\n\tend",
"def inradius\n (area / semiperimeter).to_f.round(precision)\n end",
"def radius #:nodoc:\n 0\n end",
"def radius #:nodoc:\n 0\n end",
"def compute_position\n # The negative and the ninety are the fudge to compensate for our map.\n lat = @latitude_radians = radians(-@latitude)\n long = @longitude_radians = radians(@longitude + 90)\n radius = $app.globe.diameter / 2.0 - 23\n @x = radius * cos(lat) * sin(long)\n @y = radius * sin(lat)\n @z = radius * cos(lat) * cos(long)\n end",
"def calculate_circumference\n\n \t circumference = 2*3.14*@radius\n end",
"def geo_params\n @geopoint = params[:geopoint]\n @user = User.find_by(login: @geopoint[:login])\n @user\n end",
"def zip_plus_radius_to_near(params)\n # Convert zipcode + radius to lat/long+radius in lat|long|radius|units format\n if params[\"address-postalcode\"].present? # delete zip and radius params and replace with near\n radius = 25\n zip = params[\"address-postalcode\"]\n params.delete(\"address-postalcode\")\n if params[\"radius\"].present?\n radius = params[\"radius\"]\n params.delete(\"radius\")\n end\n # get coordinate\n coords = get_zip_coords(zip)\n near = \"#{coords[\"lat\"]}|#{coords[\"lng\"]}|#{radius}|mi\"\n params[:near]=near \n end\n params\n end",
"def zip_plus_radius_to_near(params)\n # Convert zipcode + radius to lat/long+radius in lat|long|radius|units format\n if params[\"address-postalcode\"].present? # delete zip and radius params and replace with near\n radius = 25\n zip = params[\"address-postalcode\"]\n params.delete(\"address-postalcode\")\n if params[\"radius\"].present?\n radius = params[\"radius\"]\n params.delete(\"radius\")\n end\n # get coordinate\n coords = get_zip_coords(zip)\n near = \"#{coords[\"lat\"]}|#{coords[\"lng\"]}|#{radius}|mi\"\n params[:near]=near \n end\n params\n end",
"def geolocation_filter(geo_coordinates, geo_radius)\n geo_radius = \"100\" if !geo_radius\n h = {\n geo_distance: {\n distance: (geo_radius.to_s + \"km\"),\n location_coordinates: geo_coordinates.to_s\n }\n }\n h\n end",
"def radius_from(x, y)\n\t\traise 'Valentine#radius_from is not implemented. Please write this method.'\n\t\t# Hint: This should be computed based on the assumption that the resulting\n\t\t# circle must pass through 12 o'clock on the base circle.\n\tend",
"def origin\n coord, address = Map.locate_user(params[:address], locate_by_ip)\n #address may not be the same as params, if params.blank?\n return coord, address\n end",
"def is_nearby?(user_lat, user_long, bus_lat, bus_long)\n\n# max distance is about 0.6 miles away 0.01 degrees\n\nmax_distance = 0.01\n\ndifference_latitudes = user_lat - bus_lat.to_f\ndifference_longitudes = user_long - bus_long.to_f\n\ndistance = Math.sqrt(difference_latitudes ** 2 + difference_longitudes ** 2)\n\ndistance <= max_distance\n\nend",
"def user_location(user)\n geo = user.geolocation\n geo.latitude = 32.7157\n geo.longitude = -117.1611\n geo.fetch_address\n geo.save\n end",
"def places_nearby_without_photos radius=15\n Place.find_by_radius(centerLatitude,centerLongitude,radius).where(\"places.id != ?\", id).where(\"places.name_status != 'unnamed' and places.id not in (select distinct photos.place_id from photos where photos.place_id is not null) and places.id not in (select distinct place_id from place_photos)\").order(\"places.type != 'Mountain', power(places.latitude - #{centerLatitude.to_f},2)+power(places.longitude - #{centerLongitude.to_f},2)\")\n end",
"def find_nearby\n locations = read_locations_from FILE\n locations.select_within_radius 100 \n locations.sort.filter_fields\n end",
"def calculate_circle_area(radius)\n area = PI * radius**2\n return area\nend",
"def update!(**args)\n @radius = args[:radius] if args.key?(:radius)\n end",
"def locations_within_locus(latitude, longitude, radius)\n uri_params = { lat: latitude, lon: longitude, radius: radius }\n @client.get('/BikePoint', uri_params)\n end",
"def nearby\n\n #select * from ( select * from Location\n # WHERE Longitude > @lngA-(@dist/(cos( radians(@latA+(@dist/68.703)))*69.172))\n # AND Longitude < @lngA+(@dist/(cos( radians(@latA+(@dist/68.703)))*69.172))\n # AND Latitude > @latA-(@dist/68.703)\n # AND Latitude < @latA+(@dist/68.703) ) AS `tmp` WHERE GEODISTANCE(@latA,@lngA ,Latitude,Longitude) < @dist\n\n #Calculate a bounding box we can use to quickly find nearby trucks\n lat = params[:lat].to_f\n lng = params[:lng].to_f\n dist = params[:radius].to_f\n latDelta = dist/68.703\n\n value = lat+(latDelta);\n rad = value/180 * Math::PI #Geocoder::Calculations.to_radians(value) #value.to_ra radians(value);\n\n lngDelta = dist/(Math.cos( rad)*69.172)\n minLng = lng-lngDelta\n maxLng = lng+lngDelta\n minLat = lat-latDelta\n maxLat = lat+latDelta\n\n\n #IFNULL( SQRT(((difX)(difX))+((difY)(difY))), 99999)\n trucks = Truck.find_by_sql \"SELECT trucks.* WHERE SQRT(((trucks.lng-#{lng})(trucks.lng-#{lng}))+((trucks.lat-#{lat})(trucks.lat-#{lat}))) < #{dist}\"\n\n render :json => trucks\n end",
"def near?(lat, long, mile_radius)\n # omitted\n end",
"def earth_radius(point)\n a = EARTH_EQUATORIAL_RADIUS\n b = EARTH_POLAR_RADIUS\n latitude = point.latitude\n\n Math.sqrt(((a**2 * Math.cos(latitude))**2 + (b**2 * Math.sin(latitude))**2) / ((a * Math.cos(latitude))**2 + (b * Math.sin(latitude))**2))\n end",
"def place_conditions \n @radius = @radius.blank? ? 10 : @radius\n origin = GeoKit::Geocoders::MultiGeocoder.geocode(\"#{@place}, Deutschland\")\n distance_sql = Address.distance_sql(origin)\n @conditions.add_condition [\"#{distance_sql} < ?\", @radius]\n end",
"def initialize(radius, coordinates)\n @radius = radius\n @coordinates = coordinates\n end",
"def circle_area(radius)\n 3.14 * radius ** 2\nend",
"def valid_radius?\n float?(radius) &&\n radius.to_f.positive? &&\n radius.to_f <= MAXIMUM_SEARCH_RADIUS_IN_KM\n end",
"def locate\n session[:lat] = params[:coords][:lat]\n session[:lng] = params[:coords][:lng]\n session[:distance] = 10\n session[:sorting] = \"distance\"\n @holes = Pothole.near([session[:lat], session[:lng]], session[:distance], :order => session[:sorting]);\n build_markers\nend",
"def search_place\n @radius = @params[:radius] if @params[:radius].present?\n @type = @params[:type] if @params[:type].present?\n if @params[:filters].present?\n places=HTTParty.get(\"https://maps.googleapis.com/maps/api/place/nearbysearch/json?location=#{@params[:lat]},#{@params[:lng]}&key=#{ENV['GOOGLE_PLACES_KEY']}&name=\"+@params[:filters]+\"&radius=#{@radius}&type=#{@type}\")\n else\n places=HTTParty.get(\"https://maps.googleapis.com/maps/api/place/nearbysearch/json?location=#{@params[:lat]},#{@params[:lng]}&key=#{ENV['GOOGLE_PLACES_KEY']}&radius=#{@radius}&type=#{@type}\")\n end\n places[\"results\"] \n end",
"def find_customers_in_radius(in_radius)\n\t\traise \"Radius should be integer\" unless in_radius.is_a?(Numeric) && in_radius >= 0\n\t\t_invited_customers = []\n\t\t@customers.each do |customer|\n\t\t\tdistance = calculate_distance(customer[\"latitude\"].to_f, customer[\"longitude\"].to_f)\n\t\t\tif (distance <= in_radius)\n\t\t\t\t_invited_customers << customer\n\t\t\tend\n\t\tend\n\t\t@invited_customers = _invited_customers.sort_by { |ic| ic[\"user_id\"] }\n\tend",
"def search\n dogpark = Dogpark.near(\n params[:postcode] + ', NSW Australia',\n params[:radius] || 10,\n units: :km\n )\n\n #if not radius not specified, params radius returns nil\n #||Because we have 5, if the radius is empty, it will default to the 5 because of the logic of the || \"or\" expression. \"or\" will always evaluate to the truthy thing.\n render json: dogpark.to_json\n end",
"def bounding_box(distance, radius = R)\n\t\t\traise ArgumentError.new(\"Invalid distance or radius\") if distance < 0 or radius < 0\n\n\t\t\t# angular distance in radians on a great circle\n\t\t\tangular_distance = distance / radius\n\n\t\t\tmin_latitude = (self.latitude * D2R) - angular_distance\n\t\t\tmax_latitude = (self.latitude * D2R) + angular_distance\n\n\t\t\tif min_latitude > MIN_LATITUDE and max_latitude < MAX_LATITUDE\n\t\t\t\tlongitude_delta = Math::asin(Math::sin(angular_distance) / Math::cos(self.latitude * D2R))\n\t\t\t\t\n\t\t\t\tmin_longitude = (self.longitude * D2R) - longitude_delta\n\t\t\t\tmin_longitude += 2.0 * Math::PI if (min_longitude < MIN_LONGITUDE)\n\t\t\t\t\n\t\t\t\tmax_longitude = (self.longitude * D2R) + longitude_delta;\n\t\t\t\tmax_longitude -= 2.0 * Math::PI if (max_longitude > MAX_LONGITUDE)\n\t\t\telse\n\t\t\t\t# a pole is within the distance\n\t\t\t\tmin_latitude = [min_latitude, MIN_LATITUDE].max\n\t\t\t\tmax_latitude = [max_latitude, MAX_LATITUDE].min\n\t\t\t\t\n\t\t\t\tmin_longitude = MIN_LONGITUDE\n\t\t\t\tmax_longitude = MAX_LONGITUDE\n\t\t\tend\n\t\t\t\n\t\t\treturn {\n\t\t\t\t:latitude => Range.new(min_latitude * R2D, max_latitude * R2D),\n\t\t\t\t:longitude => Range.new(min_longitude * R2D, max_longitude * R2D),\n\t\t\t}\n\t\tend",
"def search_route_point\n (lat, lon) = params[:point].split(\",\")\n radius = params[:radius]\n\n results = Route.select(\"distinct name_route, cod_route\")\n .where(\"ST_DWithin('POINT(#{lat} #{lon})', path, ?)\", \"#{radius}\")\n render json: results\n end",
"def distanceToSearchCenter(centerLat, centerLong)\n\n # kilometers\n earthRadius = 6371 \n\n buildingLat = self.gis_lat\n buildingLong = self.gis_long\n\n buildingLatRad = buildingLat/180 * Math::PI\n centerLongRad = centerLong/180 * Math::PI\n\n\n dLat = (centerLat-buildingLat)/180 * Math::PI;\n dLon = (centerLong-buildingLong)/180 * Math::PI;\n\n a = Math.sin(dLat/2) * Math.sin(dLat/2) +\n Math.cos(buildingLatRad) * Math.cos(centerLongRad) *\n Math.sin(dLon/2) * Math.sin(dLon/2);\n\n c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));\n\n distanceMeters = 6371*1000 * c; \n puts distanceMeters\n distanceMeters\n end",
"def find_city(lat,lng)\n if Geocoder::Calculations.distance_between([lat,lng], [40.698390,-73.98843]) < 20\n \"newyork\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [40.76813,-73.96439]) < 20\n \"newyork\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [37.76423,-122.47743]) < 20\n \"sanfrancisco\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [37.76912,-122.42593]) < 20\n \"sanfrancisco\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [48.85887,2.30965]) < 20\n \"paris\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [48.86068,2.36389]) < 20\n \"paris\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [51.51,-0.13]) < 20\n \"london\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [-23.57664,-46.69787]) < 20\n \"saopaulo\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [-23.55838,-46.64362]) < 20\n \"saopaulo\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [35.64446,139.70695]) < 20\n \"tokyo\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [35.70136,139.73991]) < 20\n \"tokyo\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [34.06901,-118.35904]) < 20\n \"losangeles\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [34.07499,-118.28763]) < 20\n \"losangeles\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [34.02663,-118.45998]) < 20\n \"losangeles\"\n elsif\n Geocoder::Calculations.distance_between([lat,lng], [50.07832,14.41619]) < 20\n \"prague\"\n else\n \"unknown\"\n end\n end",
"def lat\n round(@lat)\n end",
"def update!(**args)\n @lat = args[:lat] if args.key?(:lat)\n @lon = args[:lon] if args.key?(:lon)\n @radius = args[:radius] if args.key?(:radius)\n end",
"def circle_zone(lat, lon, count, options = {})\n url = 'http://api.openweathermap.org/data/2.5/find'\n new(options.merge(lat: lat, lon: lon, cnt: count)).retrieve url\n end",
"def geo_dist(from, to)\n return 40000 if [from.lat, from.lon, to.lat, to.lon].any?(&:nil?)\n EARTH_DIAMETER * Math.asin(Math.sqrt(\n Math.cos(from.lat) * Math.cos(to.lat) *\n Math.sin((from.lon - to.lon)/2) ** 2 +\n Math.sin((from.lat - to.lat)/2) ** 2\n ))\nend",
"def is_nearby?(user_lat, user_long, bus_lat, bus_long)\n\t\t(user_lat - bus_lat).abs <= 0.01 && (user_long - bus_long).abs <= 0.01\n\n\tend",
"def initialize(latitude_a, longitude_a, latitude_b, longitude_b)\n @latitude_a = to_radians(latitude_a.to_f)\n @latitude_b = to_radians(latitude_b.to_f)\n @latitude_difference = to_radians(latitude_b.to_f - latitude_a.to_f)\n @longitude_difference = to_radians(longitude_b.to_f - longitude_a.to_f)\n @earths_radius_in_km = 6371\n end",
"def places_nearby_without_title_photos radius=15\n Place.find_by_radius(centerLatitude,centerLongitude,radius).where(\"places.id != ?\", id).where(\"places.name_status != 'unnamed' and places.id not in (select distinct photos.place_id from photos where photos.place_id is not null)\").order(\"places.type != 'Mountain', power(places.latitude - #{centerLatitude.to_f},2)+power(places.longitude - #{centerLongitude.to_f},2)\")\n end",
"def ice_cream_places(location, radius)\n places_url = Addressable::URI.new(\n :scheme => \"https\",\n :host => \"maps.googleapis.com\",\n :path => \"maps/api/place/nearbysearch/json\",\n :query_values => {:key => \"AIzaSyC3od3aEKzgeEb8H3_6b29HX3qHXWIB248\",\n :location => location,\n :radius => radius,\n :sensor => false,\n :keyword => \"ice cream\"}\n ).to_s\n\n response = JSON.parse(RestClient.get(places_url))[\"results\"]\n all_locations = {}\n response.each do |place|\n name = place[\"name\"]\n location = place[\"geometry\"][\"location\"]\n location_string = \"#{location[\"lat\"]},#{location[\"lng\"]}\"\n all_locations[name] = location_string\n end\n all_locations\nend",
"def public_lat\n gps_hidden && user_id != User.current_id ? nil : lat\n end",
"def bounding_box(lat, lon, radius_meters)\n radius_meters = radius_meters.to_f\n delta_lat = radius_meters / DEG_LAT_IN_METERS\n delta_lon = radius_meters / (DEG_LAT_IN_METERS * Math.cos(lat * DEG_TO_RAD))\n [\n lat - delta_lat,\n lon - delta_lon,\n lat + delta_lat,\n lon + delta_lon\n ]\n end",
"def approx_near_scope_options(latitude, longitude, radius, options)\n lat_attr = geocoder_options[:latitude]\n lon_attr = geocoder_options[:longitude]\n {\n :conditions => \\\n [\"#{lat_attr} BETWEEN ? AND ? AND #{lon_attr} BETWEEN ? AND ?\"] +\n coordinate_bounds(latitude, longitude, radius),\n :order => options[:order],\n :limit => limit_clause(options)\n }\n end",
"def index\n # show overview of users (both walkers and non-walkers)\n # allow user to filter on (non-)walkers\n # position of these people should be shown on a map (aprox. not exact)\n\n # start with 10 users\n # radius = 10km\n LoadNearbyUsers(10, false, current_user.id);\n end",
"def bounds\n coords = Geocoder.coordinates(params[:location]);\n @lat = session[:lat];\n @lng = session[:lng];\nend",
"def area_of_circle(radius)\n Math::PI*(radius*radius)\nend",
"def to_h\n {\n radius: radius,\n latitude: coordinates.latitude,\n longitude: coordinates.longitude\n }\n end",
"def create_within radius\n Geo::Radius::Rectangular.create_from self\n end",
"def is_nearby(user_latitude, user_longitude, bus_latitude, bus_longitude)\n (user_longitude - bus_longitude).abs <= 0.01 && (user_latitude - bus_latitude).abs <= 0.01\n end",
"def radius=(kms)\n if kms < 6357.0 || kms > 6378.0\n raise Error, \"Proposed radius '#{kms}' is out of range\"\n end\n\n @radius = kms\n end",
"def index\n\t\trender text: \"Cannot show nearby locations without a lat and lon.\", status: :bad_request and return unless params[\"lat\"] && params[\"lon\"]\n\t\tlat = Location.convert_lat_or_lon_to_d(params[\"lat\"])\n\t\tlon = Location.convert_lat_or_lon_to_d(params[\"lon\"])\n\t\tputs \"LAT:#{lat}\", \"LON:#{lon}\"\n\n\t\tangular_radius = @@DISTANCE / @@EARTH_RADIUS\n\t\tlat_min = lat - angular_radius\n\t\tlat_max = lat + angular_radius\n\t\tputs \"LAT_MAX:#{lat_max}\", \"LAT_MIN:#{lat_min}\"\n\n\t\tdelta_lon = Math.asin(Math.sin(angular_radius) / Math.cos(lat))\n\t\tlon_min = lon - delta_lon\n\t\tlon_max = lon + delta_lon\n\t\tputs \"LON_MAX:#{lon_max}\", \"LON_MIN:#{lat_min}\"\n\n\t\tlocations = nil\n\t\tif params[\"food\"]\n\t\t\tlocations = Location.joins({ vehicles: { vendor: :foods}})\n\t\t\t\t\t\t\t.where(\"foods.name ilike ? OR foods.name ilike '%everything%'\", \"%#{params['food']}%\").where(\"status = 'APPROVED'\")\n\t\t\t\t\t\t\t.where(\"lat BETWEEN ? AND ?\", lat_min, lat_max).where(\"lon BETWEEN ? AND ?\", lon_min, lon_max)\n\t\t\t\t\t\t\t.where(\"acos(sin(?) * sin(lat) + cos(?) * cos(lat) * cos(lon - ?)) <= ?\", lat, lat, lon, angular_radius)\n\t\t\t\t\t\t\t# formula distance = arccos(sin(lat1) · sin(lat2) + cos(lat1) · cos(lat2) · cos(lon1 - lon2)) * earth_radius\n\t\t\t\t\t\t\t# doesn't take into account poles or the 180th Meridian\n\t\telse\n\t\t\tlocations = Location.joins(:vehicles).where(\"status = 'APPROVED'\")\n\t\t\t\t\t\t\t.where(\"lat BETWEEN ? AND ?\", lat_min, lat_max).where(\"lon BETWEEN ? AND ?\", lon_min, lon_max)\n\t\t\t\t\t\t\t.where(\"acos(sin(?) * sin(lat) + cos(?) * cos(lat) * cos(lon - ?)) <= ?\", lat, lat, lon, angular_radius)\n\t\tend\n\t\trespond_to do |format|\n\t\t\tformat.json { render json: locations }\n\t\t\tformat.html { render :nothing }\n\t\tend\n\tend",
"def longitude\n end",
"def circumference_of_circle(radius)\n 2 * Pi * radius\nend",
"def user_location_info\n if current_user.present? && current_user.current_sign_in_ip != \"127.0.0.1\"\n @user_info = Geocoder.search(current_user.current_sign_in_ip).first\n elsif request.remote_ip != \"127.0.0.1\"\n @user_info = Geocoder.search(request.remote_ip).first \n # else #static ip for unit testing \n # @user_info= Geocoder.search(\"213.180.204.26\").first\n end \n return @user_info\n end",
"def dist_user(a, b)\n earth_R = 6371e3 #The earth radius, im meters!\n φ1 = (a[\"latitude\"]).to_f * Math::PI / 180\n φ2 = (b[\"coords\"][\"latitude\"]).to_f * Math::PI / 180\n Δφ = ((b[\"coords\"][\"latitude\"]).to_f-(a[\"latitude\"]).to_f)* Math::PI / 180\n Δλ = ((b[\"coords\"][\"longitude\"]).to_f-(a[\"longitude\"]).to_f)* Math::PI / 180\n a = Math.sin(Δφ/2)**2+Math.cos(φ1)*Math.cos(φ2)*Math.sin(Δλ/2)**2\n earth_R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))\n end",
"def distance(userlat, userlon, homelat, homelon)\n dlon = homelon - userlon\n dlat = homelat - userlat\n a = (Math.sin(rpd(dlat)/2))**2 + Math.cos(rpd(userlat)) * Math.cos((rpd(homelat))) * (Math.sin(rpd(dlon)/2))**2\n c = 2 * Math.atan2( Math.sqrt(a), Math.sqrt(1-a)) * 3956 * 5280\n return c\n end",
"def radius\n radius = (@cubic_root.to_f * 0.1).to_i\n radius.zero? ? 1 : radius\n end",
"def north_radius(xy, cluster)\n north_arr = []\n x, y = xy[0], xy[1]\n ny = y - 1\n in_cluster = cluster.include?([x, ny])\n while in_cluster == true\n \tnorth_arr << [x, ny]\n \tny -= 1\n \tin_cluster = false unless cluster.include?([x, ny])\n end\n radius = north_arr.length\n return radius \n end",
"def georadius(key, longitude, latitude, radius, unit = \"m\", with_coordinates: false, with_distance: false, with_hash: false, count: nil, order: nil, store: nil, store_distance: nil)\n\t\t\t\t\targuments = [key, longitude, latitude, radius, unit]\n\t\t\t\t\t\n\t\t\t\t\tif with_coordinates\n\t\t\t\t\t\targuments.append(\"WITHCOORD\")\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\tif with_distance\n\t\t\t\t\t\targuments.append(\"WITHDIST\")\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\tif with_hash\n\t\t\t\t\t\targuments.append(\"WITHHASH\")\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\tif count\n\t\t\t\t\t\targuments.append(\"COUNT\", count)\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\tif order\n\t\t\t\t\t\targuments.append(order)\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\treadonly = true\n\t\t\t\t\t\n\t\t\t\t\tif store\n\t\t\t\t\t\targuments.append(\"STORE\", store)\n\t\t\t\t\t\treadonly = false\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\tif store_distance\n\t\t\t\t\t\targuments.append(\"STOREDIST\", storedist)\n\t\t\t\t\t\treadonly = false\n\t\t\t\t\tend\n\t\t\t\t\t\n\t\t\t\t\t# https://redis.io/commands/georadius#read-only-variants\n\t\t\t\t\tif readonly\n\t\t\t\t\t\tcall(\"GEORADIUS_RO\", *arguments)\n\t\t\t\t\telse\n\t\t\t\t\t\tcall(\"GEORADIUS\", *arguments)\n\t\t\t\t\tend\n\t\t\t\tend",
"def area radius \n puts radius * 2 * PI\n end",
"def latitude\n end",
"def initialize(r)\n\t\t@radius = r\n\tend",
"def getlocation\r\n @myip = remote_ip()\r\n # based off freegeoip.net is really terrible\r\n result = Geocoder.search(@myip)\r\n @mylat = result.latitude\r\n @mylong = result.longitude\r\n @mycity = result.address\r\n #51.243048, -0.588458\r\n end",
"def api_params\n params.permit(:address, :latitude, :longitude, :radius, groups:[])\n end",
"def latitude; end",
"def georadius(*args, **geoptions)\n geoarguments = _geoarguments(*args, **geoptions)\n\n send_command([:georadius, *geoarguments])\n end",
"def is_nearby(user_latitude, user_longitude, bus_latitude, bus_longitude)\n (user_longitude - bus_longitude).abs <= 0.01 && (user_latitude - bus_latitude).abs <= 0.01\n end"
] |
[
"0.6757389",
"0.6453448",
"0.6337139",
"0.632312",
"0.63168544",
"0.6278281",
"0.6186694",
"0.6147105",
"0.60826516",
"0.60636944",
"0.6050005",
"0.6031478",
"0.60247606",
"0.60247606",
"0.59974486",
"0.5990237",
"0.5941987",
"0.59351134",
"0.58927363",
"0.5878909",
"0.58781505",
"0.58731604",
"0.5863455",
"0.5852934",
"0.584861",
"0.5836379",
"0.58171153",
"0.5805312",
"0.5794834",
"0.5781074",
"0.577315",
"0.5747087",
"0.5695581",
"0.5694366",
"0.5687339",
"0.5687339",
"0.568504",
"0.56754565",
"0.5668156",
"0.56458944",
"0.56458944",
"0.5639172",
"0.5636896",
"0.563549",
"0.5628085",
"0.5625579",
"0.56237495",
"0.56201184",
"0.56154203",
"0.5614888",
"0.5609135",
"0.56087023",
"0.5593822",
"0.55817163",
"0.55605423",
"0.5557814",
"0.5551174",
"0.5549693",
"0.5522138",
"0.55218315",
"0.550976",
"0.5499681",
"0.54961896",
"0.54924524",
"0.54703695",
"0.5452307",
"0.54447496",
"0.5440452",
"0.5432529",
"0.5431687",
"0.5429838",
"0.54166764",
"0.5413521",
"0.5405258",
"0.54034346",
"0.5403174",
"0.5400323",
"0.53960115",
"0.53927994",
"0.53917444",
"0.5381636",
"0.53808814",
"0.5379473",
"0.5363623",
"0.5363405",
"0.5353167",
"0.5344443",
"0.53420323",
"0.5341392",
"0.5339596",
"0.5336089",
"0.5334097",
"0.5332305",
"0.5323183",
"0.5323067",
"0.5314971",
"0.53146064",
"0.5313609",
"0.5311883",
"0.53073275",
"0.53057253"
] |
0.0
|
-1
|
POST /api/bikes/reserve/:id Dont let a user reserve a bike unless they have a payment method added and are in good standing Expected params: XApiKey: api_key
|
def reserve # Start Ride
return render json: { error: "This bike is not available to reserve" }, status: :forbidden unless @bike.available?
begin
ActiveRecord::Base.transaction do
@bike.current_ride = Ride.build_from_user_bike(@user, @bike)
@bike.reserved!
case params[:payment_type]
when "subscription"
render json: { error: "Subscription has not been implemented yet" }, status: :bad_request
raise ActiveRecord::Rollback
when "prepay"
@user.validates_payment_and_good_standing
@bike.current_ride.trans = Transaction.charge_user_for_ride(@user, @bike.current_ride, "prepay")
else # :per_minute
# put pay_per_minute logic here
end
@bike.save!
print "Reserved Bike #{@bike.id} - scheduling bike-reserved-email"
puts Time.now
minutes = 5
delay = "#{minutes}m"
Rufus::Scheduler.singleton.in delay do
if (Ride.find(@bike.current_ride.id).progress?)
ApplicationMailer.bikes_been_reserved_for(minutes, @user, @bike.id).deliver_now
print "Sent email "
puts Time.now
end
end
end
rescue User::PaymentMethodException, User::BraintreeException => e
render json: { error: e.message },
status: :payment_required,
location: api_new_payment_path
rescue User::NotInGoodStandingException => e
render json: { error: e.message },
status: :forbidden,
location: api_collections_path
rescue ActiveRecord::RecordInvalid => e
render :json => { :error => e.message },
status: :unprocessable_entity
rescue Transaction::Rejected => e
render :json => { :error => e.message },
status: :bad_request
else
render json: {bike: @bike.to_json({methods: :code}), transction: @bike.current_ride.trans}
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def bike_params\n params.require(:bike).permit(:bike_index_uid, :user_id)\n end",
"def set_bike\n @bike = Bike.find(params[:id])\n authorize @bike\n end",
"def bike_params\n params.require(:bike).permit(:bikeid, :serialnumber, :rating, :condition, :maintenance, :style, :size, :color, :availability, :lastcheck, :location, :fare, :accessories, :picture)\n end",
"def reserved\n @book = Book.find(params[:book_id])\n @reservation = Reservation.new(\n user_id: current_user.id,\n book_id: @book.id,\n price: @book.price\n )\n @reservation.save!\n end",
"def bike_params\n params.require(:bike).permit(:status, :miles, :last_fix)\n end",
"def my_bike_params\n params.require(:bike).permit(:title, :bike_type, :description, :daily_price, :address_line_1, :address_line_2, :zipcode, :city, :country, :image)\n end",
"def set_bike\n @bike = Bike.find(params[:id])\n end",
"def set_bike\n @bike = Bike.find(params[:id])\n end",
"def set_bike\n @bike = Bike.find(params[:id])\n end",
"def set_bike\n @bike = Bike.find(params[:id])\n end",
"def set_bid\n @bid = @item.bids.find_by(id: params[:id])\n render json: { errors: { detail: \"Bid not found\" } }, status: :unauthorized and return unless @bid\n end",
"def bid_params\n params.require(:bid).permit(:price, :payout, :availability, :notes, :maintenance_request_id, :contractor_id, :approved, :info_requested)\n end",
"def bike_rack_params\n params.require(:bike_rack).permit(:address, :quantity, :latitude, :longitude)\n end",
"def update(params)\n # TODO: API expects both priority and branchcode to update branch, bug in Koha module C4::Reserves::ModReserve\n raise ArgumentError, \"need both priority and branchcode params!\" unless params[:priority] && params[:branchcode]\n headers = {\n 'Cookie' => @context[:koha_rest_api_cookie],\n 'Content-Type' => 'application/json'\n }\n http = Net::HTTP.new(\"xkoha\", 8081)\n uri = URI(\"#{intranet(:koha_rest_api)}holds/#{params[:reserve_id]}\")\n res = http.put(uri, params.to_json, headers)\n expect(res.code).to eq(\"200\"), \"got unexpected #{res.code} when updating reserve.\\nResponse body: #{res.body}\"\n res.body\n end",
"def set_api_v1_booking\n @api_v1_booking = Booking.find(params[:id])\n end",
"def buy_params\n params.require(:buy).permit(:user_id, :box_id)\n end",
"def find_bikes\n user_id = params[\"user_id\"]\n bike_ids = get_bike_ids(user_id)\n bikes = []\n bike_ids.each {|bike_id|\n bikes.push(get_bike(bike_id, user_id))\n }\n update_bike_database(bikes, user_id)\n render json: { new_bikes: bikes }\n end",
"def set_bike_rack\n @bike_rack = BikeRack.find(params[:id])\n end",
"def reserve(params)\n AmazonProcessor.validate_reservation_response params\n raise PreconditionsError, 'Payment state should be :created' unless payment.created?\n r_amount = Remit::RequestTypes::Amount.new ({value: payment.amount, currency_code: 'USD'})\n caller_ref = new_caller_reference\n request = Remit::Reserve::Request.new ({\n recipient_token_id: recipient_token,\n sender_token_id: params[:tokenID],\n caller_reference: caller_ref,\n transaction_amount: r_amount,\n charge_fee_to: 'Caller'\n })\n\n response = remit.reserve(request)\n\n raise ApiInteractionError, response.errors.join('; ') unless response.errors.empty?\n\n update_attribute :transaction_id, response.reserve_result.transaction_id\n update_attribute :caller_reference, caller_ref\n payment.update_attribute :state, :reserved\n end",
"def bike_params\n params.require(:bike).permit(:name, :user_name, :year, :color)\n end",
"def set_bike_by_uid\n @bike = Bike.find_by( bike_index_uid: params[:id])\n end",
"def reservation_params\n params.permit(:client_id, :user_id, :status, :items, :sale, :to_reserve)\n end",
"def create\n @bike = Bike.new(bike_params)\n @bike.compare_vehicles = params[:bike][:compare_vehicles]\n\n if @bike.save\n audit(@bike, current_user)\n render json: @bike, status: :created #serializer: Web::V1::BikeSerializer\n else\n render json: @bike.errors, status: :unprocessable_entity\n end\n end",
"def release_bike\n fail 'No bikes available' if working_bikes.empty?\n bikes.delete working_bikes.pop\n end",
"def release_bike\n# the method will 'raise' an exception stating no bikes, if\n# the @rack array is empty\n raise \"No bikes available\" if @rack.empty?\n# Otherwise by implicit return it will instantiate a new Bike\n Bike.new\n end",
"def create\n @bike = Bike.new(params.permit(:bike_index_uid, :user_id))\n @bike.hash_code = generate_hash\n\n respond_to do |format|\n if @bike.save\n format.html { redirect_to @bike, notice: 'Your bike is now verified!' }\n format.json { render :show, status: :created, location: @bike }\n else\n format.html { render :new }\n format.json { render json: @bike.errors, status: :unprocessable_entity }\n end\n end\n end",
"def reserve_params\n params.require(:reserve).permit(:ordernumber, :customer_id, :orderdate, :summary, :user_id, :user, :pay)\n end",
"def set_bid\n @bid = Bid.find_by({\n :id => params[:id],\n :auction_id => params[:auction_id]})\n\n render json: nil, status: :not_found if @bid.nil? || @bid.auction.seller.id != @user.id\n end",
"def bid_params\n params.require(:bid).permit(:bid_price, :user_id)\n end",
"def create\n #birdspotter id must be present\n if params[:birdspotter].blank?\n render json: {\n status: 400,\n message: \"Skaparens id saknas.\" \n }\n end\n \n #at least one bird must be present\n if params[:bird].blank?\n render json: {\n status: 400,\n message: \"En birdspot måste innehålla minst en fågel.\" \n }\n end\n \n #latitude and longitude must be present\n if params[:latitude].blank? || params[:longitude].blank?\n render json: {\n status: 400,\n message: \"En birdspot måste innehålla latitud och longitude.\" \n }\n end\n \n #check if birdspotter exists\n if Api::V1::Birdspotter.exists?(params[:birdspotter])\n \n #if exists find birdspotter\n @birdspotter = Api::V1::Birdspotter.find_by_id(params[:birdspotter])\n \n #create a new spot and append to birdspotter\n @spot = Api::V1::Spot.create(:latitude => params[:latitude], :longitude => params[:longitude])\n if @spot.save\n @birdspotter.spots << @spot\n \n #iterate through all birds and append each bird to newly created spot\n params[:bird].tr(' ','').split(',').each do |bird_id|\n if Api::V1::Bird.exists?(bird_id)\n @bird = Api::V1::Bird.find_by_id(bird_id)\n @spot.birds << @bird\n else\n render json: {\n status: 404,\n message: \"En eller flera fåglar med det id:t finns inte.\"\n }\n end\n end\n else\n render json: {\n status: 400,\n message: @spot.errors.full_messages \n }\n end\n else\n render json: {\n status: 404,\n message: \"Skapare med det id:t finns inte.\" \n }\n \n end\n \n render json: { \n status: 201,\n message: \"Din birdspot är registerad. Tack!\", \n spots: Api::V1::SpotSerializer.new(@spot) \n }\n end",
"def create\n @item = Item.find_by(id: params[:auction_uniq_id])\n @bid = Bid.new(params.require(:bid).permit(:auction_uniq_id, :bid_amount))\n # @item.notify_price = @bid.bid_amount\n #@bid.save\n respond_to do |format|\n if @bid.save\n format.html { redirect_to @bid, notice: 'Bid was successfully created.' }\n format.json { render json: @bid, status: :created, location: @bid }\n else\n format.html { render action: \"new\" }\n format.json { render json: @bid.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @new_option = Option.new(option_params)\n\n if @new_option.save\n params[:bike_id] || OptionAvailable.create(bike_id: params[:bike_id], option_id: @new_option.id)\n render json: @new_option\n else\n render error: { error: 'No puedo crear la opción' }, status: 400\n end\n end",
"def bag_params\n params.require(:bag).permit(:user_id, :quantity, :product_id, :product_variant_id, :purchased)\n end",
"def reserve(value, currency, sender_token_id, caller_reference, options = {})\n submit Reserve.new(options.merge(\n :transaction_amount => {:value => value, :currency_code => currency},\n :sender_token_id => sender_token_id,\n :caller_reference => caller_reference\n ))\n end",
"def release_bike\n unless self.bikes.length > 0\n raise(\"No bikes available\")\n end\n bike = Bike.new\n return bike\n end",
"def buy\n shipment = Shipment.find(params[:shipment_id])\n shipment.update_column(:affiliate_shipping_account, params[:affiliate_shipping_account] == \"true\")\n EasyPost.api_key = shipment.easy_post_api_key\n\n begin\n ep_shipment = EasyPost::Shipment.retrieve(params[:ep_shipment_id])\n easypost_purchase(shipment, params[:rate_id], ep_shipment)\n ShipmentItem.where(shipment_id: shipment.id, special_status: \"\").update_all(special_status: :shipped)\n rescue => e\n flash[:error] = e.message + params[:ep_shipment_id]\n return redirect_back(fallback_location: admin_root_path)\n end\n\n redirect_to admin_store_shipment_path(shipment)\n end",
"def create\n @bid_item = BidItem.new(bid_item_params)\n @bid_item.seller_id = current_user.id\n @bid_item.current_price = @bid_item.starting_price\n respond_to do |format|\n if @bid_item.save\n format.html { redirect_to @bid_item, notice: 'Bid item was successfully created.' }\n format.json { render :show, status: :created, location: @bid_item }\n else\n format.html { render :new }\n format.json { render json: @bid_item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bay_params\n params.require(:bay).permit(:nomenclatura, :battery_bank_id, :lightning_arrester_id, :reactor_id, :substation_id, :switch_id, :transformer_id, blade_ids: [])\n end",
"def bid_params\n params.require(:bid).permit(:inspection_id, :costRepair, :feeSeismicUpg, :feeAdmin, :payPlan_id, :status, :title)\n end",
"def brass_params\n params.require(:brass).permit(:name, :caliber_id)\n end",
"def create_booking(params)\n credentials = Concierge::Credentials.for(\"SAW\")\n SAW::Client.new(credentials).book(params)\n end",
"def update\n @bike = Bike.find(params[:id])\n @bike.compare_vehicles = params[:bike][:compare_vehicles]\n\n if @bike.update(bike_params)\n audit(@bike, current_user)\n render json: @bike, status: :ok #serializer: Web::V1::BikeSerializer\n else\n render json: @bike.errors, status: :unprocessable_entity\n end\n end",
"def bid_params\n params.require(:bid).permit(:shop_id, :driver_id, :go_at, :come_back, :pass1_id, :pass2_id, :pass3_id, :pass4_id, :cangodrive, :nbrplace, :withreturn)\n end",
"def booking_params\n params.permit(:user_id, :job_id, :acceptance)\n end",
"def bid_params\n params.require(:bid).permit(:price)\n end",
"def bike_params\n params.require(:bike).permit(:kind, :brand, :component)\n end",
"def create_bid\n @instrument.bids.create!(user: current_user, price: @instrument.price)\n end",
"def boook_params\n params.require(:boook).permit(:isbn, :title, :price, :publish_id, :published, :cd)\n end",
"def set_bid\n @booking = Booking.find(params[:id])\n @presenter = current_user.presenter\n \n if !@presenter.presenter_profile\n flash[:info] = \"You must create your profile before you can do this\"\n redirect_to edit_presenter_profile_path(@presenter) and return\n elsif @presenter.presenter_profile.bio.nil?\n flash[:info] = \"You must wait for your profile to be approved before you can do this\"\n redirect_to root_url and return\n end\n\n if @booking.presenters.include? @presenter\n flash[:info] = \"You have already expressed interest in this booking\"\n redirect_to root_url and return\n else\n @booking.presenters << @presenter\n @bid = @booking.bids.find_by(presenter: @presenter)\n @bid.bid_date = DateTime.now\n @bid.rate = params[:rate]\n @bid.save\n end\n\n Notification.send_message(@booking.creator.user, \"#{@presenter.first_name} has expressed an interest in this booking.\", booking_path(@booking), :bid)\n flash[:success] = \"You have successfully placed a bid on this booking.\"\n redirect_to root_url\n end",
"def create\n @reserf = Reserve.new(reserf_params)\n @reserf.busy = true\n\n respond_to do |format|\n if @reserf.save\n format.html { redirect_to root_path, notice: 'Reserve was successfully created.' }\n format.json { render :show, status: :created, location: @reserf }\n else\n format.html { render :new }\n format.json { render json: @reserf.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_bikepart\n @bikepart = Bikepart.find(params[:id])\n end",
"def bought_item_params\n params.require(:bought_item).permit(:name, :price, :apartment_id, :user_id)\n end",
"def set_reserve\n @reserve = Reserve.find(params[:id])\n end",
"def set_kingsizeb\n @kingsizeb = Kingsizeb.find(params[:id])\n end",
"def set_bid\n @bid = Bid.find params[:id]\n end",
"def reserve_params\n params.require(:reserve).permit(:marketdate, :stockstatus, :hhv, :llv, :hdate, :ldate, :profit, :loss, :plratio, :optadvise, :note)\n end",
"def bid_params\n params.require(:bid).permit(:user_id, :item_id, :amount, :qty)\n end",
"def bids_params\n params.require(:bid).permit(:name)\n end",
"def create\n @bike = Bike.new(params[:bike])\n @bike.user = current_user\n \n respond_to do |format|\n if @bike.save\n format.html { redirect_to @bike, notice: 'Bike was successfully created.' }\n format.json { render json: @bike, status: :created, location: @bike }\n else\n format.html { render action: \"new\" }\n format.json { render json: @bike.errors, status: :unprocessable_entity }\n end\n end\n end",
"def reserve_for(key)\n reserves.fetch(key)\n end",
"def seat_booking_params\n params.require(:seat_booking).permit(:booking_id, :seat_id, :ticket_type, :price)\n end",
"def set_bid\n @bid = Bid.find(params[:id])\n end",
"def release_bike\n Bike.new\n end",
"def place_hold\n request = {\n method: :put,\n url: \"#{endpoint_url(group_id)}/hold\",\n body: body,\n headers: headers,\n query: query,\n }\n\n submit request\n end",
"def create\n @used_bike = UsedBike.new(used_bike_params)\n\n if @used_bike.save\n adding_images(params)\n render json: @used_bike, status: :created, serializer: Web::V1::UsedBikeSerializer\n else\n render json: @used_bike.errors, status: :unprocessable_entity\n end\n end",
"def set_bid\n @bid = @pet.bids.find_by!(number: params[:id])\n end",
"def create\n @bike_rack = BikeRack.new(bike_rack_params)\n\n respond_to do |format|\n if @bike_rack.save\n flash[:success] = 'Bike rack was successfully created.'\n format.html { redirect_to @bike_rack }\n format.json { render :show, status: :created, location: @bike_rack }\n else\n flash[:danger] = 'There was a problem with creating Bike rack.'\n format.html { render :new }\n format.json { render json: @bike_rack.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @used_bike = UsedBike.find(params[:id])\n\n if @used_bike.update(used_bike_params)\n adding_images(params)\n head :no_content\n else\n render json: @used_bike.errors, status: :unprocessable_entity\n end\n end",
"def boost_params\n params.require(:boost).permit(:name, :description, :price, :profile, :user_id)\n end",
"def create\n\n @rental = Rental.new(rental_params)\n @rental.start_time = Time.now\n respond_to do |format|\n if @rental.save\n Bike.where(:id => @rental.bike_id).update(available: 'f')\n\n format.html { redirect_to @rental, notice: 'Yay! You just rented a bike!' }\n format.json { render :show, status: :created, location: @rental }\n else\n format.html { render :new }\n format.json { render json: @rental.errors, status: :unprocessable_entity }\n end\n end\n end",
"def reserved_params\n params.require(:reserved).permit(:name, :email, :pax, :address, :KTP, :title)\n end",
"def v1_beer_params\n params.require(:v1_beer).permit(:name, :brand, :price, :store)\n end",
"def set_reserve\n @reserve = Reserve.find(params[:id])\n end",
"def review_business(int_xxid, oauth_token, extra_params={})\n preserve_original_http(Config[\"panda\"][\"host\"]) do\n params = {\n 'body' => 'This business is very business-like and I would do business with this business again if I have business with them.',\n 'source' => 'CSE',\n 'subject' => 'Review made by API',\n 'value' => 3,\n 'int_xxid' => int_xxid,\n 'oauth_token' => oauth_token\n }.merge(extra_params)\n\n post '/rats/add_rating', params\n\n assert_response(@response, :success)\n\n @parsed_response['RatingID']\n end\n end",
"def booking_params\n params.require(:booking).permit(:user_id, :item_id, :start_date, :end_date, :has_paid, :amount)\n end",
"def release_bike\n #fail 'No bikes available' if @bikes.empty?\n fail 'No bikes available' if empty?\n #use private helper method empty? Single Responsibility Principle\n #@bikes.pop use private attr_reader\n #Bike.new\n bikes.pop\n end",
"def create\n @kingsizeb = Kingsizeb.new(kingsizeb_params)\n\n respond_to do |format|\n if @kingsizeb.save\n format.html { redirect_to @kingsizeb, notice: 'Kingsizeb was successfully created.' }\n format.json { render :show, status: :created, location: @kingsizeb }\n else\n format.html { render :new }\n format.json { render json: @kingsizeb.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @user = current_user\n @product = Product.find(params[:product_id])\n @bid = @user.bids.build\n @product.high_bidder = @user.id\n @bid.product = @product\n @product.current_price = @product.current_price + @product.current_price * 0.1\n @product.save\n \n #implement later for time controlled bids\n #if @product.end_time - Time.now > 0\n #\n #send\n\n respond_to do |format|\n if @bid.save\n \n format.html { redirect_to :back, notice: 'Bid was successfully created.' }\n format.json { render json: @bid, status: :created, location: @bid }\n else\n format.html { render action: \"new\" }\n format.json { render json: @bid.errors, status: :unprocessable_entity }\n end\n end\n \n end",
"def barbershop_client_params\n params.require(:barbershop_client).permit(:name, :phone, :rating, :address_id, :user_id)\n end",
"def create\n\t\tbooking = Booking.new(booking_params)\n\n\t if booking.save\n\t \tPeekBooker.use_a_boat(booking.size, booking.timeslot_id)\n\t \tPeekBooker.delete_overlap_assignments(booking.timeslot_id)\n\t \tPeekBooker.upd_availability(booking.timeslot_id)\n\t \t\n\t \trender json: booking, status: 201\n\t end\n\tend",
"def refresh_bikes\n bike_ids = params[\"bike_ids\"].split(',')\n user_id = params[\"user_id\"]\n\n bike_ids.each {|bike_id|\n strava_bike = get_bike(bike_id, user_id)\n bike = Bike.find_by(strava_gear_id: bike_id)\n bike.update(distance_done: strava_bike[\"distance\"])\n }\n end",
"def booking_params\n params.require(:booking).permit( :check_in, :checkout, :service_id)\n end",
"def set_bid\n @bid = Bid.find(params[:id])\n end",
"def set_bid\n @bid = Bid.find(params[:id])\n end",
"def set_bid\n @bid = Bid.find(params[:id])\n end",
"def set_bid\n @bid = Bid.find(params[:id])\n end",
"def set_bid\n @bid = Bid.find(params[:id])\n end",
"def set_bid\n @bid = Bid.find(params[:id])\n end",
"def bid_params\n params.require(:bid).permit(:amount, :user_id, :auction_id)\n end",
"def create\n # @user = User.find(params[:user_id])\n # parking = Parking.find(params[:parking_id])\n # @booking = @user.bookings.build(parking: parking, user: @user)\n @booking = @user.bookings.build(parking: @parking)\n @booking.update(booking_params)\n\n\n\n respond_to do |format|\n if @booking.save\n format.html { redirect_to @booking, notice: 'Booking was successfully created.' }\n format.json { render :show, status: :created, location: @booking }\n else\n format.html { render :new }\n format.json { render json: @booking.errors, status: :unprocessable_entity }\n end\n end\n end",
"def auction_seckill_params\n params.require(:auction_seckill).permit(:product_id, :discount, :date, :play, :active, :user_id)\n end",
"def create\n # @booking = Booking.new(booking_params)\n #@available_seats = Bus.find(:id Journey.find_by(id: booking_params[:journey_id]).bus_id).max_seats - Booking.where(journey_id: booking_params[:journey_id]).sum(:seats_count)\n #@available_seats\n p booking_params\n# booking_params[:status] = \"Pending\"\n @booking = current_user.bookings.build(booking_params)\n @booking.status =\"1\"\n respond_to do |format|\n if @booking.save\n flash[:success] = \"Booking Successful!!!\"\n format.html { redirect_to @booking}\n format.json { render :show, status: :created, location: @booking }\n else\n format.html { render :new }\n format.json { render json: @booking.errors, status: :unprocessable_entity }\n end\n end\n end",
"def release_bike\n raise 'no bike to be released' if empty?\n raise \"Can't release broken bike\" unless @bikes.last.working?\n @bikes.pop\n end",
"def release_bike\n raise(RuntimeError, \"No bikes available\") unless !empty?\n raise(\"Cannot release a broken bike\") if @bikes.last.broken?\n @bikes.pop\n end",
"def book(params)\n client = jsonrpc(ENDPOINT)\n result = client.invoke(\"PlaceBookingV1\", reservation_details(params))\n\n if result.success?\n parse_book_response(params, result.value)\n else\n result\n end\n end",
"def booking_params\n params.require(:booking).permit(:user_id, :home_id, :start_date, :end_date, :price)\n end",
"def add_new_bid\n @product = Product.find(params[:id])\n bid = Bid.create\n\n if params[:max_bid].to_i >= @product.price\n @product.update_attributes(end_date: Time.now)\n respond_to do |format|\n format.html { redirect_to @product, notice: 'Purchased' }\n format.json { render :show, status: :ok, location: @product }\n end\n elsif params[:max_bid].to_i < @product.current_price\n respond_to do |format|\n format.html { redirect_to @product, alert: 'Your bid must be higher than the starting price !' }\n format.json { render :show, status: :ok, location: @product }\n end\n else\n bid.max_bid = params[:max_bid]\n bid.product_id = @product.id\n bid.user_id = current_user.id\n bid.save\n respond_to do |format|\n format.html { redirect_to @product, notice: 'Your bid has been placed' }\n format.json { render :show, status: :ok, location: @product }\n end\n end\n end",
"def place_bid(bid)\n put(:bid, bid)\n end",
"def create_alt\n @parking_space = ParkingSpace.find(params[:id])\n if check_overlap\n redirect_to booking_fail_path\n return\n end\n @parking_space.booking.create(booking_params)\n redirect_to root_path\n end",
"def request_trip\n request_trip_params = {\n date: Date.today,\n rating: rand(1..5),\n cost: rand(1..100),\n passenger_id: params[:passenger_id],\n driver_id: Driver.where(available: true).first.id,\n }\n #create the trip\n a_trip = Trip.new(request_trip_params)\n if a_trip.save\n #update status of driver\n driver_id = a_trip.driver_id\n a_trip.driver.available = false\n a_trip.driver.save\n redirect_to trip_path(a_trip.id) \n return\n else \n render :new \n return\n end\n end"
] |
[
"0.6272552",
"0.61437535",
"0.61261225",
"0.6092075",
"0.5988227",
"0.5956369",
"0.5892189",
"0.5867415",
"0.5867415",
"0.5867415",
"0.5823128",
"0.58165795",
"0.57885647",
"0.57801604",
"0.5774022",
"0.575455",
"0.57489383",
"0.57458764",
"0.57410276",
"0.57336164",
"0.5720759",
"0.5708781",
"0.5704543",
"0.5661441",
"0.5633246",
"0.5594646",
"0.5579984",
"0.5574063",
"0.5563756",
"0.5551355",
"0.5533555",
"0.5520285",
"0.5503538",
"0.5502194",
"0.5480426",
"0.54763174",
"0.54720116",
"0.5471314",
"0.5462868",
"0.5448684",
"0.5447079",
"0.5442697",
"0.54306364",
"0.5425994",
"0.54206246",
"0.54161096",
"0.54125243",
"0.54045975",
"0.5397156",
"0.5391175",
"0.53847784",
"0.5384733",
"0.5382091",
"0.53820866",
"0.53809804",
"0.5378546",
"0.5377212",
"0.5375795",
"0.5373867",
"0.5350775",
"0.53480834",
"0.534767",
"0.53453416",
"0.53396076",
"0.5339071",
"0.53310776",
"0.53219163",
"0.53185356",
"0.5316538",
"0.5312374",
"0.5301573",
"0.5299614",
"0.52988064",
"0.5297442",
"0.52952725",
"0.52952355",
"0.52915263",
"0.5283457",
"0.5279187",
"0.5276605",
"0.52719736",
"0.5271394",
"0.52690387",
"0.52690387",
"0.52690387",
"0.52690387",
"0.52690387",
"0.52690387",
"0.52670085",
"0.52665603",
"0.5264659",
"0.5263195",
"0.5261028",
"0.5255723",
"0.5255607",
"0.5242541",
"0.523745",
"0.5228706",
"0.5228209",
"0.52226186"
] |
0.62075686
|
1
|
POST /api/bikes/return/:id Expected params: XApiKey: api_key latitude: lat longitude: long payment_method_nonce: braintree token
|
def return # End Ride
params.require(:latitude)
params.require(:longitude)
@ride = @bike.current_ride
return render json: { error: 'Could not find the current ride associated with this bike' }, status: :not_found if @ride.nil?
return render json: { error: 'Cannot return a bike that is not reserved' }, status: :forbidden unless (@bike.reserved?)
return render json: { error: 'You are not the current owner of this bike' }, status: :forbidden if (@user != @ride.user)
# TODO: get name for this location by nearest Coordinate with name...
@location = Coordinate.find_or_initialize_by(latitude: params[:latitude], longitude: params[:longitude])
render :json => { :error => @location.errors.full_messages } unless @location.save
@ride.stop_location = @location
@ride.stop_time = DateTime.now
@ride.status = Ride.statuses[:complete]
return render :json => { :error => @ride.errors.full_messages } unless @ride.save
# CHARGE FOR RIDE
begin
# TODO: Finish this
# @transaction = Transaction.charge_user_for_ride(@user, @ride)
# @transaction.save!
# put specific rescues here
rescue Exception => e
return render json: { error: e }, status: :internal_server_error
# TODO: What happens if transaction fails
# @user.status === User::STATUS[:outstanding]
ensure
@bike.location = @location
@bike.current_ride = nil
@bike.status = Bike.statuses[:available]
return render json: { error: @bike.errors.full_messages } unless @bike.save
end
# TODO: make this @ride.summary
render :json => @ride.to_json if @ride.save
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def post_doge_token_dropin\r\n if current_user then\r\n tokens = params[:num_tokens]\r\n # CREATE TEST TRANSACTION TODO Make it work\r\n # Handle Taxes for Taxcloud\r\n customer = @current_user\r\n # TODO Change this to retrieved destination\r\n test_destination = TaxCloud::Address.new(\r\n address1: '317 112th Ave NE',\r\n address2: 'Room 1016',\r\n city: 'Bellevue',\r\n state: 'WA',\r\n zip5: '98004'\r\n )\r\n transaction = TaxCloud::Transaction.new(\r\n customer_id: customer.customer_id,\r\n cart_id: '1',\r\n origin: DogeTaxCloud.doge_origin,\r\n destination: test_destination\r\n )\r\n transaction.cart_items << DogeTaxCloud.doge_token(tokens)\r\n session[:transaction] = transaction\r\n #lookup = transaction.lookup # Returns a TaxCloud::Responses::Lookup\r\n puts \"TAX AMOUNT:\"\r\n# puts lookup.tax_amount\r\n\r\n # Error if no transaction is in the process\r\n if session[:transaction] == nil then\r\n render json: {error: \"Transaction Not Properly Set Up\"}, status: 401\r\n return\r\n else\r\n transaction = session[:transaction]\r\n end\r\n\r\n # Process payment base cost, add sales tax amount\r\n amount = calculate_base_cost(tokens) #+ lookup.tax_amount\r\n\r\n # Transaction.sale and create a new Customer id if none is specified\r\n if @current_user.customer_id == nil then\r\n result = Braintree::Customer.create\r\n if result.success? then\r\n # If there was no customer ID, add customer id\r\n if @current_user.customer_id == nil then\r\n @current_user.customer_id = result.customer.id\r\n @current_user.save\r\n end\r\n else\r\n # Handle customer creation failure\r\n render json: {error: result.message}, status: 401\r\n session[:transaction] = nil\r\n return\r\n end\r\n end\r\n\r\n result = Braintree::Transaction.sale(\r\n payment_method_nonce: params[:payment_method_nonce],\r\n amount: amount,\r\n customer_id: @current_user.customer_id,\r\n options: {\r\n submit_for_settlement: true,\r\n store_in_vault_on_success: true\r\n }\r\n )\r\n\r\n if result.success? then\r\n # Transaction customer ID should be the same as user customer ID\r\n if result.transaction.customer_details.id.to_i != @current_user.customer_id.to_i then\r\n flash[:error] = \"Unexpected Error\"\r\n session[:transaction] = nil\r\n raise \"Customer ID Mismatch\"\r\n else\r\n # Handle Taxes for Taxcloud\r\n transaction.order_id = result.transaction.order_id\r\n transaction.authorized_with_capture # returns \"OK\" or raises error \r\n end\r\n else\r\n # Deal with the settlement errors\r\n render json: {error: result.message}, status: 401\r\n return\r\n end\r\n render json: {success: \"Purchase Success!\"}, status: 200\r\n else\r\n render json: {error: \"Not Logged In\"}, status: 401\r\n end\r\n end",
"def checkout\n @order = Order.find params[:id]\n @gateway_request = Braintree::GatewayRequest.new(@order.to_gateway_request.merge(:response_url => gateway_response_order_url(@order)))\n end",
"def create\n @bid = Bid.new(bid_params)\n @bid.driver_id = current_user.id\n if @bid.nbrplace == 1\n @bid.pass1_id = 0\n elsif @bid.nbrplace == 2\n @bid.pass1_id = 0\n @bid.pass2_id = 0\n elsif @bid.nbrplace == 3\n @bid.pass1_id = 0\n @bid.pass2_id = 0\n @bid.pass3_id = 0\n else\n @bid.pass1_id = 0\n @bid.pass2_id = 0\n @bid.pass3_id = 0\n @bid.pass4_id = 0\n end\n\n if @bid.withreturn ==false\n respond_to do |format|\n if @bid.save\n format.html { redirect_to root_path, notice: 'Annonce enregistrée.' }\n format.json { render :root, status: :created, location: @bid }\n else\n format.html { render :new }\n format.json { render json: @bid.errors, status: :unprocessable_entity }\n end\n end\n else\n @return = Bid.new(bid_params)\n @return.driver_id=current_user.id\n if @return.nbrplace == 1\n @return.pass1_id = 0\n elsif @return.nbrplace == 2\n @return.pass1_id = 0\n @return.pass2_id = 0\n elsif @return.nbrplace == 3\n @return.pass1_id = 0\n @return.pass2_id = 0\n @return.pass3_id = 0\n else\n @return.pass1_id = 0\n @return.pass2_id = 0\n @return.pass3_id = 0\n @return.pass4_id = 0\n end\n @return.isreturn=true\n @return.save\n @bid.save\n respond_to do |format|\n if @bid.save\n format.html { redirect_to root_path, notice: 'Aller-retour créé.' }\n format.json { render :root, status: :created, location: @bid }\n else\n format.html { render :new }\n format.json { render json: @bid.errors, status: :unprocessable_entity }\n end\n end\n end\n end",
"def request_token(*args)\n args_options = args.extract_options!\n uri = '/api_paynow/api_paynow.asmx/api_paynow_authentication_new'\n\n options ={\n body: {\n psbID: self.preferred_psbid, \n username: self.preferred_username, \n secureCode: self.preferred_securecode,\n inv: args_options[:invoice],\n itm: '1', \n amt: args_options[:amount],\n paypal_amt: '',\n curr_type: 'TH',\n com: '',\n method: 1,\n language: args_options[:lang],\n resp_front_url: \"#{self.preferred_domain}/orders/#{args_options[:order_id]}/checkout/paysbuy_return\",\n resp_back_url: \"#{self.preferred_domain}/paysbuy_callbacks/notify?encryted_order_number=#{self.class.encrypt args_options[:invoice]}\",\n opt_fix_redirect: 1,\n opt_fix_method: '',\n opt_name: args_options[:name],\n opt_email: args_options[:email],\n opt_mobile: '',\n opt_address: \"\",\n opt_detail: \"\"\n }\n }\n\n result = self.class.post(base_uri + uri, options)\n attempt = 0\n\n # if have got an unexpected result, try to get the correct result again\n # from API document, return result should start with '00'\n # if not start with '00' should try again (then, try 5 times)\n while(!(result.parsed_response[\"string\"] =~ /^00/) && \n (attempt <= 5)) do\n\n result = self.class.post(base_uri + uri, options)\n attempt += 1\n end\n\n result.parsed_response[\"string\"].gsub(/^00/, \"\")\n end",
"def create_bepaid_bill\n # Don't touch real web services during of test database initialization\n return if Rails.env.test?\n\n user = self\n\n bp = BePaid::BePaid.new Setting['bePaid_baseURL'], Setting['bePaid_ID'], Setting['bePaid_secret']\n\n amount = user.monthly_payment_amount\n\n #amount is (amoint in BYN)*100\n bill = {\n request: {\n amount: (amount * 100).to_i,\n currency: 'BYN',\n description: 'Членский взнос',\n email: 'jekhor@gmail.com',\n notification_url: 'https://hackerspace.by/admin/erip_transactions/bepaid_notify',\n ip: '127.0.0.1',\n order_id: '4444',\n customer: {\n first_name: 'Cool',\n last_name: 'Hacker',\n },\n payment_method: {\n type: 'erip',\n account_number: 444,\n permanent: 'true',\n editable_amount: 'true',\n service_no: Setting['bePaid_serviceNo'],\n }\n }\n }\n req = bill[:request]\n req[:email] = user.email\n req[:order_id] = user.id\n req[:customer][:first_name] = user.first_name\n req[:customer][:last_name] = user.last_name\n req[:payment_method][:account_number] = user.id\n\n begin\n res = bp.post_bill bill\n logger.debug JSON.pretty_generate res\n rescue => e\n logger.error e.message\n logger.error e.http_body if e.respond_to? :http_body\n user.errors.add :base, \"Не удалось создать счёт в bePaid, проверьте лог\"\n end\n end",
"def order_to_kraken\n kraken = Kraken::Client.new(ENV['KRAKEN_PUBLIC_KEY'], ENV['KRAKEN_SECRET_KEY'])\n origin_price = cal_origin_price\n Process.fork do\n txid = kraken.buy_sell(amount, origin_price, \"buy\", currency+payment_type, \"+3600\")\n MyLog.kraken(\"#{Process.pid}\")\n if txid.is_a?(Hash)\n self.txid = txid[:error]\n else\n self.txid = txid\n end\n self.save\n self.order!\n end\n end",
"def create\n @bike = Bike.new(params.permit(:bike_index_uid, :user_id))\n @bike.hash_code = generate_hash\n\n respond_to do |format|\n if @bike.save\n format.html { redirect_to @bike, notice: 'Your bike is now verified!' }\n format.json { render :show, status: :created, location: @bike }\n else\n format.html { render :new }\n format.json { render json: @bike.errors, status: :unprocessable_entity }\n end\n end\n end",
"def api_response\n {\n payment_nonce_uuid: @gateway_nonce_record.uuid,\n gateway_type: @gateway_type\n }\n end",
"def insert_hwb\n type = OrderType.find_by_name(\"hwb\")\n \n res = RResponse.new\n\n Order.transaction do\n begin\n data = params[\"order\"]\n\n # hack created by for now\n data[\"created_by\"] = current_user.account\n data[\"order_type_id\"] = type.id\n \n \n data[\"bill_number\"] = (params[\"is_quote\"] == 'false') ? type.generate_bill_number(self.get_config_param(:hwb_offset)) : nil\n \n data[\"dim_factor\"] = 194\n \n if (params[\"multiple_pickup\"] != nil && params[\"multiple_pickup\"] == \"on\") \n data[\"pickup_locations\"] = JSON::parse(params[\"locations\"])\n end\n \n # read bill_to bill_third_party checkbox: if on, bill third-party. otherwise, bill shipper.\n if (params[\"bill_third_party\"].nil? || params[\"bill_third_party\"] != 'on')\n data[\"bill_to_id\"] = params[\"shipper\"][\"company_id\"]\n end\n \n ##############################################################################################\n # HACK order[billing_method_id] -- might need this in order since it's defined company-wide\n ##############################################################################################\n data[\"billing_method_id\"] = 1\n ##############################################################################################\n \n # super can handle it from here...\n order = Order.create(data)\n\n # get OrderTypeEntity list\n entities = order.type.entities(:include => [:domain])\n entities.each do |e|\n if (e.name != 'consignee' || (e.name == 'consignee' && params[\"has_consignee\"] != nil && params[\"has_consignee\"] == 'on') )\n data = params[e.name]\n data[:order_id] = order.id\n data[:order_type_entity_id] = e.id\n oe = OrderEntity.create(data)\n end\n end\n \n # apply markup & fuel_surcharge from order's bill_to to the order.\n types = SystemRevenuType.find(:all)\n revenus = SystemRevenu.find(:all)\n revenus.each do |sr|\n \n field = order.bill_to.domain.fields.find_by_name(sr.name) \n raise RException.new(\"Create HWB -- Could not locate company's revenu-field '#{sr.name}'\") if field.nil?\n \n # first get default value \n value = field.config[:value] \n \n # if the bill_to company has this Revenu field explicitly defined, apply that instead.\n if (!order.bill_to.domain_values.nil? && !order.bill_to.domain_values[field.id].nil?)\n value = order.bill_to.domain_values[field.id] \n end \n \n # apply insurance only if declared_value was defined\n if (sr.name != 'insurance' || !order.declared_value.nil?)\n # apply multiplier type to insurance only -- all other revenus (markup, fuel-surcharge) get percentage\n type = (sr.name != 'insurance') ? types.find { |t| (t.name == 'percentage') ? true : false} : types.find { |t| (t.name == 'multiplier') ? true : false} \n OrderRevenu.create(\n :order_id => order.id,\n :system_revenu_id => sr.id,\n :system_revenu_type_id => type.id,\n :value => value,\n :config => field.config #<-- this column contains Ext.form.Field config\n ) \n end \n end\n # log order-creation\n OrderLog.create(\n :order_id => order.id,\n :account_id => current_user.account.id,\n :order_log_type_id => OrderLogType.find_by_name('status').id,\n :subject => 'Order created',\n :msg => 'New ' + type.name\n )\n res.data[:order] = {\n :id => order.id,\n :bill_number => order.bill_number\n }\n res.success = true\n res.msg = 'Created order #' + order.bill_number.to_s\n end \n end\n\n respond(res)\n end",
"def create_bill(params)\n build_header_auth('/bills', API_VERSION_1, 'POST')\n build_request()\n p_hash = {}\n p_hash[\"bill\"] = {\"identifier\" => params['id'],\n \"amount_cents\" => params['amount_cents'],\n \"bill_template_id\" => params['bill_template_id'],\n \"memo\" => params['memo'],\n \"content\" => params['content'],\n \"recurring\" => params['recurring'],\n \"customer_id\" => params['customer_id'],\n \"date\" => params['date']}\n req_body = p_hash.to_json.to_s\n request = Net::HTTP::Post.new(@uri.request_uri)\n @header.each do |name, value|\n request[name] = value\n end\n # request.each do |name, value|\n # puts name+\" : \"+value\n # end\n request.set_body_internal(req_body)\n response = @http.request(request)\n # response.body = JSON.parse(response.body)\n return response\n end",
"def add_bank_account\n\n get_balanced_key\n\n account_uri = params[:account_uri]\n company_name = \"Mindfire Solutions\"\n\n ##You can set your customer business / company name here \n customer = Balanced::Customer.new({name: company_name}).save\n customer_uri = customer.href\n get_customer = Balanced::Customer.fetch(customer_uri)\n \n bank_account = Balanced::BankAccount.fetch(account_uri)\n bank_account.associate_to_customer(customer_uri)\n \n ##befor debiting your customer you need to verify their bank account as per balanced payment\n bank_account = Balanced::BankAccount.fetch(account_uri)\n verify_bank_account = bank_account.verify\n verification = Balanced::BankAccountVerification.fetch(verify_bank_account.href)\n verification.confirm(\n amount_1 = 1,\n amount_2 = 1\n )\n \n amount_in_dollars = params[:amount].to_i\n #amount_in_dollars * 100 convert into cents\n debit = bank_account.debit(:amount => amount_in_dollars * 100, appears_on_statement_as: \"Debit Amount\")\n \n ##You can save the response in your db for future use\n #debit.transaction_number\n #debit.amount\n #debit.statusdebit.created_at\n \n #get your balanced marketplace\n marketplace = Balanced::Marketplace.my_marketplace\n \n credit = get_marketplace_bank_account.credit(:amount => debit.amount, appears_on_statement_as: \"Credit Amount\")\n\n \n return render json: {success: [\"Debit Transaction:: #{debit.attributes}\", \"Credit Transaction:: #{credit.attributes}\"] }\n\n end",
"def settle\n \n\n if params[\"code\"]\n auth_code = params[\"code\"]\n end \n url = \"https://api.venmo.com/v1/oauth/access_token\"\n @response = HTTParty.post(url, :query => {:client_id => '1916', :client_secret => 'eGcyNHaysfbFGZ6xkMffUw3gGrKFzksG', :code => auth_code})\n user = @response[\"user\"]\n @access_token = @response[\"access_token\"]\n @refresh_token = @response[\"refresh_token\"]\n @email = params[:email]\n @amount = params[:amount]\n \n url = \"https://api.venmo.com/v1/payments\"\n @amount = HTTParty.post(url, :query => { \"access_token\" => @access_token, :email => @email, :amount => @amount, :note => 'PayUp'})\n redirect_to bets_path\n end",
"def gateway_response\n @order = Order.find params[:id]\n @response = Braintree::GatewayResponse.new(params)\n @order.update_with_response(@response)\n if @response.is_successful?\n current_user.cart.clear\n flash[:notice] = @response.message_for_success\n redirect_to order_path(@order)\n else\n flash[:notice] = @response.message_for_failure\n redirect_to checkout_order_path(@order)\n end\n end",
"def index # returns all bikes within a certain radius\n ## TODO: use coordinates later, when more campuses and bikes.\n # # defaults radius to half mile, and coordinate to requesting ip address\n # radius = params[:radius] ? params[:radius] : 0.5\n # coordinates = params[:coordinates] ? params[:coordinates] : request.location\n # puts coordinates\n # @bikes = Coordinate.near(coordinates, radius).joins(:bikes)\n @bikes = Bike.available\n render json: @bikes\n end",
"def post_buy_token\n # Whitelist parameters for buying tokens\n purchase_params \n end",
"def create\n nonce_from_the_client = params[:payment_method_nonce]\n # Use payment method nonce here...\n result = Braintree::Transaction.sale(\n :amount => params[:total_cost],\n :payment_method_nonce => nonce_from_the_client,\n :options => {\n :submit_for_settlement => true\n }\n )\n\n if result.success?\n flash[:notice] = \"success!: #{result.transaction.id}\"\n new_payment = Payment.create(\n total_cost: params[:total_cost])\n\n new_payment.save\n main_reservation = Reservation.find(params[:reservation_id])\n reservation = Reservation.where(check_in_date: main_reservation.check_in_date, user_id: main_reservation.user_id)\n reservation.each do |ind_record|\n ind_record.payment_id = new_payment.id\n ind_record.save\n end\n elsif result.transaction\n flash[:notice] = \"Error processing transaction:\"\n puts \" code: #{result.transaction.processor_response_code}\"\n puts \" text: #{result.transaction.processor_response_text}\"\n else\n flash[:notice] = result.errors\n end\n end",
"def verify_charge(id)\n\n response = get_request(\"#{base_url}/transactions/#{id}/verify\")\n return response\nend",
"def yunbi_submit_orders (orders:nil, quote:\"bts\", base:\"cny\")\n $LOG.info (method(__method__).name) { {\"parameters\"=>method(__method__).parameters.map { |arg| \"#{arg[1]} = #{eval arg[1].to_s}\" }.join(', ') } }\n\n return nil if orders.nil? or orders.empty?\n\n #client.post '/api/v2/orders/multi', market: 'btccny', orders: [{side: 'buy', volume: '0.15', price: '2955.0'}, {side: 'sell', volume: '0.16', price: '2956'}]\n cancel_ids = []\n new_orders = [] \n orders.each { |e|\n case e[\"type\"]\n when \"cancel\"\n cancel_ids.push e[\"id\"]\n when \"ask\", \"bid\"\n type = e[\"type\"]\n new_type = ((type == \"bid\" or type == \"buy\") ? \"buy\" : \"sell\")\n order = { side: new_type, volume: e[\"volume\"].to_s, price: e[\"price\"].to_s }\n new_orders.push order\n #yunbi_new_order quote:(e[\"quote\"] or quote), base:(e[\"base\"] or base), type:e[\"type\"], price:e[\"price\"], volume:e[\"volume\"]\n end\n }\n\n client = new_yunbi_client\n\n market = quote + base\n\n ret = []\n #client.post '/api/v2/orders/multi', market: 'btccny', orders: [{side: 'buy', volume: '0.15', price: '2955.0'}, {side: 'sell', volume: '0.16', price: '2956'}]\n begin\n response = client.post '/api/v2/orders/multi', market:market, orders:new_orders\n $LOG.debug (method(__method__).name) { {\"response of new_orders\"=>response} }\n ret.push( {\"response_new_orders\"=>response} )\n rescue Exception => e\n puts e\n $LOG.debug (method(__method__).name) { {\"error of new_orders\"=>e} }\n ret.push( {\"response_new_orders\"=>e} )\n end\n\n cancel_ids.each { |id|\n begin\n response = yunbi_cancel_order id:id\n ret.push( {(\"response_cancel \"+id.to_s)=>response} )\n rescue Exception => e\n puts e\n $LOG.debug (method(__method__).name) { {(\"error of cancel order \"+id.to_s)=>e} }\n ret.push( {(\"response_cancel \"+id.to_s)=>e} )\n end\n }\n\n return ret\n\nend",
"def new\n @checkout = Checkout.new\n\n if params[:bike_id]\n @checkout.bike_id = params[:bike_id]\n else\n @bikes = current_user.admin? ? Bike.operational : Bike.operational.find_all_by_location_id(session[:location_id])\n @bikes = @bikes.order(:id)\n end\n end",
"def show\n pr params\n pr payu_verify_return\n # IF payed, push to queue - onl once\n # todo\n end",
"def create\n response = Books::Return.call(params: params)\n\n if response.success?\n render json: response.rent, status: :created\n else\n render json: response.error, status: :unprocessable_entity\n end\n end",
"def find_bikes\n user_id = params[\"user_id\"]\n bike_ids = get_bike_ids(user_id)\n bikes = []\n bike_ids.each {|bike_id|\n bikes.push(get_bike(bike_id, user_id))\n }\n update_bike_database(bikes, user_id)\n render json: { new_bikes: bikes }\n end",
"def add_credit_card\n\n get_balanced_key\n card_uri = params[:card_uri]\n\n company_name = \"Mindfire Solutions\"\n customer = Balanced::Customer.new({name: company_name}).save\n customer_uri = customer.href\n get_customer = Balanced::Customer.fetch(customer_uri)\n card = Balanced::Card.fetch(card_uri)\n card.associate_to_customer(customer_uri)\n \n\n amount_in_dollars = params[:amount].to_i\n #amount_in_dollars * 100 convert into cents\n\n debit = card.debit(:amount => amount_in_dollars * 100, appears_on_statement_as: \"Debit Amount\")\n \n ##You can save the response in your db for future use\n #debit.transaction_number\n #debit.amount\n #debit.statusdebit.created_at\n \n #get the balanced market place\n marketplace = Balanced::Marketplace.my_marketplace\n \n credit = get_marketplace_bank_account.credit(:amount => debit.amount, appears_on_statement_as: \"Credit Amount\")\n\n\n return render json: {success: [\"Debit Transaction:: #{debit.attributes}\", \"Credit Transaction:: #{credit.attributes}\"] }\n\n end",
"def post(merchantid, body)\n self.class.post(\"/post/api/public/v1/accesstoken?merchantid=#{merchantid}\", :body => body)\n end",
"def create\n #birdspotter id must be present\n if params[:birdspotter].blank?\n render json: {\n status: 400,\n message: \"Skaparens id saknas.\" \n }\n end\n \n #at least one bird must be present\n if params[:bird].blank?\n render json: {\n status: 400,\n message: \"En birdspot måste innehålla minst en fågel.\" \n }\n end\n \n #latitude and longitude must be present\n if params[:latitude].blank? || params[:longitude].blank?\n render json: {\n status: 400,\n message: \"En birdspot måste innehålla latitud och longitude.\" \n }\n end\n \n #check if birdspotter exists\n if Api::V1::Birdspotter.exists?(params[:birdspotter])\n \n #if exists find birdspotter\n @birdspotter = Api::V1::Birdspotter.find_by_id(params[:birdspotter])\n \n #create a new spot and append to birdspotter\n @spot = Api::V1::Spot.create(:latitude => params[:latitude], :longitude => params[:longitude])\n if @spot.save\n @birdspotter.spots << @spot\n \n #iterate through all birds and append each bird to newly created spot\n params[:bird].tr(' ','').split(',').each do |bird_id|\n if Api::V1::Bird.exists?(bird_id)\n @bird = Api::V1::Bird.find_by_id(bird_id)\n @spot.birds << @bird\n else\n render json: {\n status: 404,\n message: \"En eller flera fåglar med det id:t finns inte.\"\n }\n end\n end\n else\n render json: {\n status: 400,\n message: @spot.errors.full_messages \n }\n end\n else\n render json: {\n status: 404,\n message: \"Skapare med det id:t finns inte.\" \n }\n \n end\n \n render json: { \n status: 201,\n message: \"Din birdspot är registerad. Tack!\", \n spots: Api::V1::SpotSerializer.new(@spot) \n }\n end",
"def register\n params = Serializer.new(self).to_params\n Response.new Request.post(\"checkout\", params)\n end",
"def create_payment(params)\n # Validation\n params = validate_input(params, @exception_array += %w[currency value])\n # The Request Body Parameters\n k2_request_pay_amount = {\n currency: params['currency'],\n value: params['value']\n }\n k2_request_pay_metadata = {\n customerId: 8_675_309,\n notes: 'Salary payment for May 2018'\n }\n create_payment_body = {\n destination: 'c7f300c0-f1ef-4151-9bbe-005005aa3747',\n amount: k2_request_pay_amount,\n metadata: k2_request_pay_metadata,\n callback_url: 'https://your-call-bak.yourapplication.com/payment_result'\n }\n create_payment_hash = K2Pay.make_hash('payments', 'POST', @access_token, 'PAY', create_payment_body)\n @threads << Thread.new do\n sleep 0.25\n @location_url = K2Connect.to_connect(create_payment_hash)\n end\n @threads.each(&:join)\n end",
"def request_withdraw\n kraken = Kraken::Client.new(ENV['KRAKEN_PUBLIC_KEY'], ENV['KRAKEN_SECRET_KEY'])\n withdraw_txid = kraken.withdraw(currency, ENV['KEY_WITHDRAW'], amount)\n if !withdraw_txid.nil? && !withdraw_txid.empty?\n self.withdraw_txid = withdraw_txid\n self.save\n self.withdraw!\n end\n # MyLog.kraken(\"WITHDRAW: #{currency} #{payment_type} -- #{amount}\")\n end",
"def create\n unread\n\n @cart = current_cart\n if @cart.line_items.empty?\n redirect_to :controller=>'main', :action=>'index', :notice => \"Your cart is empty\"\n return\n end\n\n\n @order = Order.new(params[:order])\n @order.add_line_items_from_cart(current_cart)\n\n @line_item = LineItem.find_by_cart_id(@cart)\n #getting branches\n supermarket = @line_item.product.seller.id\n @branches = Branch.find_all_by_seller_id(supermarket)\n\n # ******* sending request to PegPay server ******************\n # call the http post method\n @date = \"#{Time.now}\"\n url = URI.parse('https://41.190.131.222/pegpaytelecomsapi/PegPayTelecomsApi.asmx?WSDL')\n \n post_xml ='<?xml version=\"1.0\" encoding=\"utf-8\"?>\n <soap:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">\n <soap:Body>\n <PostTransaction xmlns=\"http://PegPayTelecomsApi/\">\n <trans>\n <DigitalSignature>'+ \"#{digital_signature}\" +'</DigitalSignature>\n <FromTelecom>'+ \"#{@order.pay_type}\" +'</FromTelecom>\n <ToTelecom>'+ \"#{@order.pay_type}\" +'</ToTelecom>\n <PaymentCode>1</PaymentCode>\n <VendorCode>MABIRA</VendorCode>\n <Password>81W30DI846</Password>\n <PaymentDate>'+ Date.today.strftime(\"%m/%d/%Y\") +'</PaymentDate>\n <Telecom></Telecom>\n <CustomerRef>'+\"#{@order.phone_no}\"+'</CustomerRef>\n <CustomerName>'+\"#{@order.name}\"+'</CustomerName>\n <TranAmount>'+\"#{@cart.total_price}\"+'</TranAmount>\n <TranCharge>0</TranCharge>\n <VendorTranId>1</VendorTranId>\n <ToAccount></ToAccount>\n <FromAccount>'+\"#{@order.phone_no}\"+'</FromAccount>\n <TranType>PULL</TranType>\n </trans>\n </PostTransaction>\n </soap:Body>\n </soap:Envelope>'\n\n peg_pay_status_code = make_http_request(url, post_xml)\n puts \"status code============================================\" \n puts peg_pay_status_code\n puts \"status code============================================\"\n # ******* end of sending request to yo! payments server ******************\n message=getTransactionStatus(peg_pay_status_code )\n message\n\n respond_to do |format|\n if peg_pay_status_code == 0\n if @order.save\n Cart.destroy(session[:cart_id])\n session[:cart_id] = nil\n Notifier.order_received(@order).deliver\n flash[:notice] = 'Thank you for your order.' \n format.html { redirect_to(:controller=>'main', :action=>'index') }\n format.json { render json: @order, status: :created, location: @order }\n else\n format.html { render action: \"new\" }\n format.json { render json: @order.errors, status: :unprocessable_entity }\n end\n else\n flash[:notice]= message\n\n format.html { render action: \"new\" }\n format.json { render json: @order.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bike_rack_params\n params.require(:bike_rack).permit(:address, :quantity, :latitude, :longitude)\n end",
"def capture(money_cents, response_code, _gateway_options)\n protected_request do\n result = braintree.transaction.submit_for_settlement(\n response_code,\n dollars(money_cents)\n )\n Response.build(result)\n end\n end",
"def payment(params)\n check_token\n\n Request.perform(:post, URI.parse(Urls::PAYMENTS_URL), headers_for_other, params.to_json)\n end",
"def create\n\t\t\t\tif api_check(params[:query])\n\t\t\t\t\tcoin = Coin.new(coin_params)\n\t\t\t\t\tcoin[:name].downcase!\n\t\t\t\t\tif coin_name_check(coin[:name])\n\t\t\t\t\t\tcoin[:api_key] = params[:query]\n\t\t\t\t\t\tif coin.save\n\t\t\t\t\t\t\ttransaction = Transaction.new(transaction_params)\n\t\t\t\t\t\t\ttransaction[:api_key] = params[:query]\n\t\t\t\t\t\t\tif transaction.save\n\t\t\t\t\t\t\t\trender json: {status: 'Success!', message: 'Saved Coins', data:coin},status: :ok\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\trender json: {status: 'Error!', message: 'Transaction Not Saved', data:transaction.errors},status: :unprocessable_entity\n\t\t\t\t\t\t\tend\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\trender json: {status: 'Error!', message: 'Coin Not Saved. ', data:coin.errors},status: :unprocessable_entity\n\t\t\t\t\t\tend\n\t\t\t\t\telse\n\t\t\t\t\t\trender json: {status: 'Error!', message: 'The only accepted coins are: Adamentium Coin, Carbonite Coin, Amazonium Coin, or Vibranium Coin'},status: :unprocessable_entity\n\t\t\t\t\tend\n\t\t\t\telse\n\t\t\t\t\trender json: {status: 'Error!', message: 'Your API-Key was not accepted. Please use one of the following: Aa11, Bb22, Cc33, or Dd44'},status: :unprocessable_entity\n\t\t\t\tend\n\t\t\tend",
"def create\n @brandid= params[:brand_id].gsub(/[{:=value>\"}]/,'').to_i\n @trajetid= params[:trajet_id].gsub(/[{:=value>\"}]/,'').to_i\n @nbrsac= params[:nbrsac].gsub(/[{:=value>\"}]/,'').to_i\n @refdrive= params[:refdrive]\n @substitution= params[:substitution]\n @trajet=Trajetpumd.find(@trajetid)\n @driver= User.find(@trajet.driver_id)\n\n @result = Braintree::Transaction.sale(\n :amount => '3.00',\n:options => {\n:submit_for_settlement => true\n})\n if @result.success?\n @trans=Transaction.new\n @trans.user_id = current_user.id\n @trans.tvalue = -3.0\n @trans.comment = \"Réservation de picking\"\n @trans.trajetpumd_id = @trajetid\n @trans.braintree_tid = @result.transaction.id\n @trans.save!\n @trans=Transaction.new\n @trans.user_id = @driver.id\n @trans.tvalue = 0\n @trans.comment = \"En attente de validation de picking\"\n @trans.trajetpumd_id = @trajetid\n @trans.braintree_tid = @result.transaction.id\n @trans.save!\n redirect_to reserver_trajet_path(brand_id:@brand_id, trajet_id:@trajetid, nbrsac:@nbrsac, refdrive:@refdrive, substitution:@substitution)\n else\n flash[:alert] = \"Problème pendant la transaction :( Merci de recommencer\"\n gon.client_token = generate_client_token\n render :new\n end\n end",
"def create\n @brainfart = Brainfart.new(brainfart_params)\n\n respond_to do |format|\n if @brainfart.save\n format.html { redirect_to @brainfart, notice: 'Brainfart was successfully created.' }\n format.json { render :show, status: :created, location: @brainfart }\n else\n format.html { render :new }\n format.json { render json: @brainfart.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @api_v1_mentorship_interest = Api::V1::MentorshipInterest.new(api_v1_mentorship_interest_params)\n\n respond_to do |format|\n if @api_v1_mentorship_interest.save\n format.html { redirect_to @api_v1_mentorship_interest, notice: 'Mentorship interest was successfully created.' }\n format.json { render :show, status: :created, location: @api_v1_mentorship_interest }\n else\n format.html { render :new }\n format.json { render json: @api_v1_mentorship_interest.errors, status: :unprocessable_entity }\n end\n end\n end",
"def money_ins_card_rebill_with_http_info(cardid, parameters, authorization, psu_ip_address, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: MoneyInsApi.money_ins_card_rebill ...'\n end\n # verify the required parameter 'cardid' is set\n if @api_client.config.client_side_validation && cardid.nil?\n fail ArgumentError, \"Missing the required parameter 'cardid' when calling MoneyInsApi.money_ins_card_rebill\"\n end\n # verify the required parameter 'parameters' is set\n if @api_client.config.client_side_validation && parameters.nil?\n fail ArgumentError, \"Missing the required parameter 'parameters' when calling MoneyInsApi.money_ins_card_rebill\"\n end\n # verify the required parameter 'authorization' is set\n if @api_client.config.client_side_validation && authorization.nil?\n fail ArgumentError, \"Missing the required parameter 'authorization' when calling MoneyInsApi.money_ins_card_rebill\"\n end\n # verify the required parameter 'psu_ip_address' is set\n if @api_client.config.client_side_validation && psu_ip_address.nil?\n fail ArgumentError, \"Missing the required parameter 'psu_ip_address' when calling MoneyInsApi.money_ins_card_rebill\"\n end\n # resource path\n local_var_path = '/v2/moneyins/card/{cardid}/rebill'.sub('{' + 'cardid' + '}', cardid.to_s)\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n # HTTP header 'Content-Type'\n header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])\n header_params[:'Authorization'] = authorization\n header_params[:'PSU-IP-Address'] = psu_ip_address\n header_params[:'PSU-Accept-Language'] = opts[:'psu_accept_language'] if !opts[:'psu_accept_language'].nil?\n header_params[:'PSU-User-Agent'] = opts[:'psu_user_agent'] if !opts[:'psu_user_agent'].nil?\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = @api_client.object_to_http_body(parameters)\n auth_names = []\n data, status_code, headers = @api_client.call_api(:POST, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'MoneyInWithCardIdOutput')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: MoneyInsApi#money_ins_card_rebill\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def pay\n @card = Creditcard.new(creditcard_params)\n\n user = current_user\n\n if @card.valid?\n result = Creditcard.create_only_creditcard_over_braintree(user.braintree_customer_id, @card)\n @braintree_cc_return = result.success? ? result.credit_card : nil\n end\n\n\n if @braintree_cc_return.present?\n @card.save\n @card.update_attributes(user_id: user.id)\n @card = Creditcard.update_creditcard(@braintree_cc_return, user.id)\n end\n\n end",
"def post(path, type, options)\n response = HTTParty.post(\n root_url(type) + path,\n headers: {\n 'X-Api-Key' => api_key.to_s,\n 'Content-Type' => 'application/json'\n },\n body: options.to_json\n )\n\n return response unless response.code >= 500\n\n raise BadGatewayError.new(\n gateway: AccesstypeAdyen::PAYMENT_GATEWAY,\n path: path,\n response_code: response.code,\n response_body: response.parsed_response\n )\n end",
"def create\n @kingsizeb = Kingsizeb.new(kingsizeb_params)\n\n respond_to do |format|\n if @kingsizeb.save\n format.html { redirect_to @kingsizeb, notice: 'Kingsizeb was successfully created.' }\n format.json { render :show, status: :created, location: @kingsizeb }\n else\n format.html { render :new }\n format.json { render json: @kingsizeb.errors, status: :unprocessable_entity }\n end\n end\n end",
"def pay_order(order_id:,\n body:)\n new_api_call_builder\n .request(new_request_builder(HttpMethodEnum::POST,\n '/v2/orders/{order_id}/pay',\n 'default')\n .template_param(new_parameter(order_id, key: 'order_id')\n .should_encode(true))\n .header_param(new_parameter('application/json', key: 'Content-Type'))\n .body_param(new_parameter(body))\n .header_param(new_parameter('application/json', key: 'accept'))\n .body_serializer(proc do |param| param.to_json unless param.nil? end)\n .auth(Single.new('global')))\n .response(new_response_handler\n .deserializer(APIHelper.method(:json_deserialize))\n .is_api_response(true)\n .convertor(ApiResponse.method(:create)))\n .execute\n end",
"def create_wepay_account\n if self.has_wepay_access_token? && !self.has_wepay_account?\n params = { :name => self.name, :description => \" User donate \" + self.donate_amount.to_s } \n response = WEPAY.call(\"/account/create\", self.wepay_access_token, params)\n\n if response[\"account_id\"]\n self.wepay_account_id = response[\"account_id\"]\n return self.save\n else\n raise \"Error - \" + response[\"error_description\"]\n end\n\n end \n raise \"Error - cannot create WePay account\"\nend",
"def getnewaddress\n @api.request 'getnewaddress'\n end",
"def settlement_account(params)\n # Validation\n params = validate_input(params, @exception_array += %w[account_name bank_ref bank_branch_ref account_number currency value])\n # The Request Body Parameters\n settlement_body = {\n account_name: params['account_name'],\n bank_ref: params['bank_ref'],\n bank_branch_ref: params['bank_branch_ref'],\n account_number: params['account_number']\n }\n settlement_hash = K2Transfer.make_hash('merchant_bank_accounts', 'POST', @access_token, 'Transfer', settlement_body)\n @threads << Thread.new do\n sleep 0.25\n @location_url = K2Connect.to_connect(settlement_hash)\n end\n @threads.each(&:join)\n end",
"def show\n if params[:id].to_i != 0\n @bike = Bike.find_by_id(params[:id].to_i)\n end\n\n if @bike.nil?\n @bike = Bike.find_by(hash_code: params[:id].to_s) \n end\n\n if !@bike.nil?\n if @bike.hash_code.nil? and @bike.user == current_user\n @bike.hash_code = generate_hash\n @bike.save\n end\n\n @api = bike_index_api\n @bike_data = JSON.parse(@api.get(\"bikes/#{@bike.bike_index_uid}\").body)\n else\n redirect_to(:bikes_unverfied, alert: \"The bike you requested could not be found by that link or code.\")\n end\n end",
"def bike_point\n TflApi::Client::BikePoint.new(self)\n end",
"def create_wepay_account\n if self.has_wepay_access_token? && !self.has_wepay_account?\n params = { :name => self.name, :description => self.description }\n response = WEPAY.call(\"/account/create\", self.wepay_access_token, params)\n\n if response[\"account_id\"]\n self.wepay_account_id = response[\"account_id\"]\n return self.save\n else\n raise \"Error - \" + response[\"error_description\"]\n end\n\n end\nraise \"Error - cannot create WePay account\"\nend",
"def billing\n user_agent = request.env['HTTP_USER_AGENT']\n #parameter = Parameter.first\n transaction_id = DateTime.now.to_i\n\n request = Typhoeus::Request.new(\"http://37.0.73.3:3778\", followlocation: true, params: {transaction_id: transaction_id, msisdn: @account.msisdn, price: \"50\"})\n\n#=begin\n request.on_complete do |response|\n if response.success?\n result = response.body\n elsif response.timed_out?\n result = Error.timeout(@screen_id)\n elsif response.code == 0\n result = Error.no_http_response(@screen_id)\n else\n result = Error.non_successful_http_response(@screen_id)\n end\n end\n\n request.run\n#=end\n return ((result.strip rescue nil) == \"1\" ? true : false)\n end",
"def get_chains_nearby distance: nil, id: nil, ip: nil, latitude: nil, longitude: nil, name: nil, stores_per_chain: nil, user: nil, zip: nil\r\n # the base uri for api requests\r\n query_builder = Configuration::BASE_URI.dup % [@version]\r\n\r\n # prepare query string for API call\r\n query_builder << \"/chains/nearby\"\r\n\r\n # process optional query parameters\r\n query_builder = APIHelper.append_url_with_query_parameters query_builder, {\r\n \"distance\" => distance,\r\n \"id\" => id,\r\n \"ip\" => ip,\r\n \"latitude\" => latitude,\r\n \"longitude\" => longitude,\r\n \"name\" => name,\r\n \"storesPerChain\" => stores_per_chain,\r\n \"user\" => user,\r\n \"zip\" => zip,\r\n }\r\n\r\n # validate and preprocess url\r\n query_url = APIHelper.clean_url query_builder\r\n\r\n # prepare headers\r\n headers = {\r\n \"user-agent\" => \"APIMATIC 2.0\",\r\n \"accept\" => \"application/json\",\r\n \"X-Api-Key\" => @x_api_key\r\n }\r\n\r\n # invoke the API call request to fetch the response\r\n response = Unirest.get query_url, headers:headers\r\n\r\n #Error handling using HTTP status codes\r\n if !(response.code.between?(200,206)) # [200,206] = HTTP OK\r\n raise APIException.new \"HTTP Response Not OK\", response.code, response.raw_body\r\n end\r\n\r\n response.body\r\n end",
"def booz_params\n params.require(:bottle_store).permit(:name, :open_time, :closed_time, :latitude, :longitude, :sat_open_times, :sat_closed_times, :sun_open_times, :sun_closed_times, :address)\n end",
"def return_bikes\n fix_bikes\n @bikes\n end",
"def create\n @bok = Bok.new(bok_params)\n\n respond_to do |format|\n if @bok.save\n format.html { redirect_to @bok, notice: 'Bok was successfully created.' }\n format.json { render :show, status: :created, location: @bok }\n else\n format.html { render :new }\n format.json { render json: @bok.errors, status: :unprocessable_entity }\n end\n end\n end",
"def payment_api_return?\n\t\ttrue\n\tend",
"def wepay_postfill\n # If the user approved the 'preapproval' and \n if params.has_key?('preapproval_id')\n @order = Order.find_by_token(params[:preapproval_id])\n unless @order.nil?\n wepay = WePay.new(Settings.wepay_client_id, Settings.wepay_access_token, _use_stage = (!Rails.env.production?))\n # Let's find the user information on Wepay end..\n response = wepay.call('/preapproval', Settings.wepay_access_token, {\n :preapproval_id => params[:preapproval_id]\n })\n \n @order.wepay_postfill(response)\n if params['status'] != 'approved' \n redirect_to :action => :share, :uuid => @order.uuid\n else\n redirect_to root_url\n end\n else\n redirect_to root_url\n end\n else\n redirect_to root_url\n end\n end",
"def bike_params\n params.require(:bike).permit(:bike_index_uid, :user_id)\n end",
"def getwalletinfo\n @api.request 'getwalletinfo'\n end",
"def submit_order()\n\tputs \"Submitting order\"\n\tdata = create_order()\n\tresponse = request_post(\"/api/order\", data)\n\tputs response.body\nend",
"def add_vat_return_with_http_info(vat_returns, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: VatReturnApi.add_vat_return ...'\n end\n # verify the required parameter 'vat_returns' is set\n if @api_client.config.client_side_validation && vat_returns.nil?\n fail ArgumentError, \"Missing the required parameter 'vat_returns' when calling VatReturnApi.add_vat_return\"\n end\n # resource path\n local_var_path = '/vat_returns'\n\n # query parameters\n query_params = {}\n\n # header parameters\n header_params = {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n # HTTP header 'Content-Type'\n header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])\n\n # form parameters\n form_params = {}\n\n # http body (model)\n post_body = @api_client.object_to_http_body(vat_returns)\n auth_names = ['api_key']\n data, status_code, headers = @api_client.call_api(:POST, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => 'VatReturn')\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: VatReturnApi#add_vat_return\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def return_params\n params.require(:return).permit(:order_numb, :truck,\n return_parts_attributes: [\n :id,\n :part_code,\n :part_desc,\n :uom,\n :order_qty,\n :confirmed,\n :qty,\n :temperature\n ]\n )\n end",
"def show\n @token = Token.find(params[:id])\n gateway = ActiveMerchant::Billing::LitleGateway.new\n \n credit_card = ActiveMerchant::Billing::CreditCard.new(\n :first_name => @token.firstname,\n :last_name => @token.lastname,\n :number => @token.cardnumber,\n :month => @token.cardmonth,\n :year => @token.cardyear,\n :verification_value => @token.cvv)\n \n options = { \n :billToAddress => {\n :name => [@token.firstname, @token.lastname].compact.join(' '),\n :address1 => @token.address1,\n :city => @token.city,\n :state => @token.state,\n :country => ('US' or @token.country),\n :zip => @token.zip,\n :email => @token.email} \n }\n if credit_card.valid?\n response = gateway.store(credit_card,options)\n \n if response.success?\n @post = \"Successfully stored token:\" \n @tokenid = response.params['litleOnlineResponse'].registerTokenResponse.litleToken \n \n else\n @message = response.message\n render :action => 'error2' \n end\n \n else\n render :action =>'error1' \n end\n \n end",
"def bid_params\n params.require(:bid).permit(:shop_id, :driver_id, :go_at, :come_back, :pass1_id, :pass2_id, :pass3_id, :pass4_id, :cangodrive, :nbrplace, :withreturn)\n end",
"def pay\n #definitin de l'url de base\n base_payment_url = 'http://197.159.2.146:7086/sprintpayapi/payment/orangemoney/request'\n #definition des headers\n\n headers: {\n 'Postman-Token': '9669f6e7-402b-4dc9-a370-472194583c32',\n 'cache-control': 'no-cache',\n 'Authorization': 'SP:XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',\n 'DateTime': 'YYYYYYYYYYYYYYYYYYYY',\n 'Content-Type': 'application/json'\n }\n\n #defintion du bodies/main content\n setBody: {\n \"amount\": 1,\n \"currency\": \"EUR\",\n \"firstName\": \"AMADOU\",\n \"lastName\": \"BAKARI\",\n \"address1\": \"Yaounde\",\n \"address2\": \"Nkolfoulou\",\n \"city\": \"Yaounde\",\n \"state\": \"Centre\",\n \"country\": \"FR\",\n \"postal\": \"0332\",\n \"mobileNumber\": \"237690000999\",\n \"emailId\": \"amadoubakari@gmail.com\",\n \"spMerchandUrl\": \"http://sprint-pay.com/\"\n }\n\n #envoi du paiement\n response = httparty.post(\n base_payment_url,\n body: setBody,\n headers: headers\n )\n\n self.class.post(\n base_payment_url,\n body: setBody,\n headers: headers\n )\n #puts response\n\n end",
"def create_return\n loan = Log.find(params[:loan_id])\n book_return = Log.create!(user: current_user, book: loan.book, loan: loan,\n classification: Log.classifications[:book_return], date: DateTime.now)\n render json: book_return, book_return: true, status: :created\n end",
"def bid\n @auction = Auction.find(params[:auction_id])\n @reward = Reward.find(params[:reward_id])\n @points_already_bid = current_user ? @reward.points_already_raised_by(current_user) : 0\n @donation = Donation.new\n @program = @auction.program\n @karma_page = false\n\n if @program\n @org = @program.organization\n @profile_fields = Profile.profile_fields(current_user, @org)[@org.url] # current_user could be nil\n if @program.auction_type == \"fixed\"\n @opportunities = Profile.fixed_opportunities_for(@org)\n @nonprofit = @org.nonprofits.first\n end\n end\n\n if current_user\n @current_karma = total_karma_for(current_user)\n else\n @current_karma = 0\n end\n\n if current_user && current_user.stripe_cus_id && !@org\n Stripe.api_key = ENV['STRIPE_SECRET_KEY']\n begin\n customer = Stripe::Customer.retrieve(current_user.stripe_cus_id)\n @default_card = customer.sources.retrieve(customer.default_card)\n rescue\n # If a similar Stripe object exists in live mode, but a test mode key was used to make this request.\n @default_card = nil\n end\n end\n end",
"def create\n PlaceHoldsJob.perform_later barcodes:,\n session_token: current_user.session_token,\n patron_key: current_user.patron_key,\n catkey: params['catkey'],\n pickup_library: params['pickup_library'],\n pickup_by_date: params['pickup_by_date']\n\n redirect_to result_path\n end",
"def send_geo_request(postcode)\n Response.new(\n response(postcode),\n response_type: :json\n )\n end",
"def checkout\n user = User.find(params[:id])\n\n render json: {\n cost: user.checkout,\n transaction: 'success'\n }\n\n\n end",
"def create\n bikes = Bike.all\n bikes.each do |bike|\n if bike.next_date_inspected == Time.now.in_time_zone\n bike.passed_inspection = false\n end\n end\n create_checkout_values\n respond_to do |format|\n if @checked_out.save\n create_bike_values\n UserMailer.check_out_email(@checked_out.user).deliver\n format.html { redirect_to home_check_out_path, notice: \"The bike was successfully checked out by #{@checked_out.user.email}.\" }\n format.json { render action: 'show', status: :created, location: @checked_out }\n else\n format.html { redirect_to home_check_out_path, :flash => @checked_out.errors }\n format.json { render json: @checked_out.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @order = Order.new(order_params)\n @service = Service.find(params[:service_id])\n @seller = @service.userID\n\n @order.service_id = @service.id\n @order.buyer_id = current_user.id\n @order.seller_id = @seller\n\n PinPayment.secret_key = 'CRuWFFtjN2m3djtcNB439A'\n card_token = params[:card_token]\n number = params[:number]\n name = params[:name]\n expiry_year = params[:expiry_year]\n expiry_month = params[:expiry_month]\n cvc = params[:cvc]\n\n charge = PinPayment::Charge.create(\n email: current_user.email,\n description: @service.description,\n amount: (@service.price * 100).floor,\n currency: 'AUD',\n ip_address: request.remote_ip,\n card: {\n number: number,\n expiry_month: expiry_month,\n expiry_year: expiry_year,\n cvc: cvc,\n name: current_user.name,\n }\n ) \n\n if charge.success?\n alert (\"yo success\")\n end\n\n\n respond_to do |format|\n if @order.save\n format.html { redirect_to root_url, notice: 'Order was successfully created.' }\n format.json { render :show, status: :created, location: @order }\n else\n format.html { render :new }\n format.json { render json: @order.errors, status: :unprocessable_entity }\n end\n end\n end",
"def my_bike_params\n params.require(:bike).permit(:title, :bike_type, :description, :daily_price, :address_line_1, :address_line_2, :zipcode, :city, :country, :image)\n end",
"def create\n @cetak_blok = CetakBlok.new(cetak_blok_params)\n\n respond_to do |format|\n if @cetak_blok.save\n format.html { redirect_to cetak_bloks_url, notice: 'Cetak blok was successfully created.' }\n format.json { render :show, status: :created, location: @cetak_blok }\n else\n format.html { render :new }\n format.json { render json: @cetak_blok.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post_request\n\n @url = 'https://api.keeptruckin.com/v1'\n @headers = { 'content-type': 'application/json', 'X-Api-Key': ENV[\"KEEP_TRUCKIN_KEY\"] } \n request = HTTParty.put(\"#{@url}/users/\", headers: @headers, \n body: \n { \n\n password: @driver_profile.password,\n driver_company_id: @driver_profile.id,\n first_name: @driver_profile.first_name, \n last_name: @driver_profile.last_name,\n email: @driver_profile.email, \n first_name: @driver_profile.first_name, \n last_name: @driver_profile.last_name, \n phone: @driver_profile.phone, \n phone_ext: @driver_profile.phone_ext, \n time_zone: @driver_profile.time_zone,\n carrier_name: @driver_profile.carrier_name, \n carrier_street: @driver_profile.carrier_street, \n carrier_city: @driver_profile.carrier_city,\n carrier_state: @driver_profile.carrier_state, \n carrier_zip: @driver_profile.carrier_zip, \n terminal_street: @driver_profile.terminal_street,\n terminal_city: @driver_profile.terminal_city, \n terminal_state: @driver_profile.terminal_state, \n terminal_zip: @driver_profile.terminal_zip, \n username: @driver_profile.username,\n drivers_license_number: @driver_profile.drivers_license_number,\n drivers_license_state: @driver_profile.drivers_license_state,\n role: @driver_profile.role }.to_json)\n # @user_response = JSON.parse(@response.body, object_class: OpenStruct)\n \n # puts @user_response.body, @user_response.message\n puts \"request Body: #{request.body}\", \"request Code: #{request.code}\", \"request Message: #{request.message}\"\n end",
"def place_settlement\n @invoice = Invoice.find(params[:invoice_id])\n\n #check settlment parms\n #create a new invoice_items describing the payment via cc or something\n @invoice.charge params[:amount], params[:payment_method], params[:note]\n\n flash[:notice] = \"Settlement Placed\"\n render \"settlement\"\n end",
"def create\n @postcard_return = PostcardReturn.new(postcard_return_params)\n\n respond_to do |format|\n if @postcard_return.save\n format.html { redirect_to @postcard_return, notice: 'Postcard return was successfully created.' }\n format.json { render :show, status: :created, location: @postcard_return }\n else\n format.html { render :new }\n format.json { render json: @postcard_return.errors, status: :unprocessable_entity }\n end\n end\n end",
"def bus_api(stpid, route)\n url_safe_stpid = URI.encode(stpid)\n url_safe_route = URI.encode(route)\n apiKey = \"UPGw2J5PBxNnF967CAMyHygeB\"\n apiLink = \"http://www.ctabustracker.com/bustime/api/v1/getpredictions?key=#{apiKey}&stpid=#{url_safe_stpid}&rt=#{url_safe_route}\"\n apiResults = open(apiLink).read\n return Hash.from_xml(apiResults)\n end",
"def returnByIdXML(params)\n begin\n Nokogiri::XML::Builder.new do |xml|\n xml.ReturnById('xmlns:i' => 'http://www.w3.org/2001/XMLSchema-instance',\n 'xmlns' => 'http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Rest', 'i:type' =>\"ReturnById\" ) {\n xml.ApplicationProfileId application_profile_id \n xml.BatchIds('xmlns:d2p1' => 'http://schemas.microsoft.com/2003/10/Serialization/Arrays', 'i:nil' => \"true\")\n xml.DifferenceData('xmlns:ns1' => 'http://schemas.ipcommerce.com/CWS/v2.0/Transactions/Bankcard', 'i:type' => \"ns1:BankcardReturn\"){\n xml['ns2'].TransactionId params[:TransactionId] ,'xmlns:ns2' => 'http://schemas.ipcommerce.com/CWS/v2.0/Transactions'\n if params[:Amount] != ''\n xml['ns1'].Amount params[:Amount]\n else\n xml['ns1'].Amount '0.00'\n end\n }\n xml.MerchantProfileId merchant_profile_id\n } \n end.to_xml\n rescue Exception => ex\n return \"transaction id and/or amount not set in xml for returnByIdXML!\"\n end \n end",
"def submit\n # validate_line_items\n Wheretocard::Response.from_order_request(self)\n end",
"def post_businesses_token_notes_with_http_info(token, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: BusinessesApi.post_businesses_token_notes ...'\n end\n # verify the required parameter 'token' is set\n if @api_client.config.client_side_validation && token.nil?\n fail ArgumentError, \"Missing the required parameter 'token' when calling BusinessesApi.post_businesses_token_notes\"\n end\n # resource path\n local_var_path = '/businesses/{token}/notes'.sub('{' + 'token' + '}', CGI.escape(token.to_s))\n\n # query parameters\n query_params = opts[:query_params] || {}\n\n # header parameters\n header_params = opts[:header_params] || {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n # HTTP header 'Content-Type'\n header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])\n\n # form parameters\n form_params = opts[:form_params] || {}\n\n # http body (model)\n post_body = opts[:debug_body] || @api_client.object_to_http_body(opts[:'body'])\n\n # return_type\n return_type = opts[:debug_return_type] || 'CardholderNoteResponseModel'\n\n # auth_names\n auth_names = opts[:debug_auth_names] || []\n\n new_options = opts.merge(\n :operation => :\"BusinessesApi.post_businesses_token_notes\",\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => return_type\n )\n\n data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: BusinessesApi#post_businesses_token_notes\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def bath_params\n params.require(:bath).permit(:name, :lat, :lon, :clean, :handicapped, :near, :supplies)\n end",
"def post(path, data = {})\n # Allow format override\n format = data.delete(:format) || @format\n # Clear cache\n expire_matching \"#{raw_path(path)}.*\"\n # Extract return unit params\n query_params = {}\n query_params[:returnUnit] = data.delete(:returnUnit) if data[:returnUnit]\n query_params[:returnPerUnit] = data.delete(:returnPerUnit) if data[:returnPerUnit]\n # Create POST request\n post_params = {\n :verbose => DEBUG,\n :method => \"post\",\n :body => form_encode(data)\n }\n post_params[:params] = query_params unless query_params.empty?\n post = Typhoeus::Request.new(\"#{protocol}#{@server}#{path}\", post_params)\n # Send request\n do_request(post, format) \n end",
"def postcard_return_params\n params.require(:postcard_return).permit(:company, :postmark, :postcard, :uid, :reason)\n end",
"def return_market_place_api(name)\n self.seller_market_places.where(:market_place_id => Spree::MarketPlace.return_market_place(name).first.id).first.api_key rescue nil\n end",
"def create\n @sender = params[:sender]\n @destination = params[:destination]\n @package = params[:package]\n @notification = params[:notification]\n @preferences = params[:preferences]\n @settlement_info = params[:settlement_info]\n @request = {\n sender: @sender,\n destination: @destination,\n package: @package,\n notification: @notification,\n preferences: @preferences,\n settlement_info: @settlement_info,\n group_id: '5241556',\n mailing_date: Date.today,\n contract_number: '0042956527',\n service_code: params[:service_code],\n mobo: {\n customer_number: params[:mobo],\n username: 'bc02d6bd3733555c',\n password: '111d1a0d29fc00aa47b66a',\n contract_number: '0042956527'\n }\n }\n puts \"**** #{@request}\"\n\n @response = CANADA_POST_SERVICE.create(\n sender: @sender,\n destination: @destination,\n package: @package,\n notification: @notification,\n preferences: @preferences,\n settlement_info: @settlement_info,\n group_id: '5241556',\n mailing_date: Date.today,\n contract_id: '0042956527',\n service_code: params[:service_code],\n mobo: {\n customer_number: params[:mobo],\n username: 'bc02d6bd3733555c',\n password: '111d1a0d29fc00aa47b66a',\n contract_number: '0042956527'\n }\n )\n puts \"Full Response: #{@response}\"\n unless @response[:create_shipping][:errors].present?\n Shipping.track_shipping(@response)\n end\n respond_to do |format|\n format.js {}\n end\n end",
"def create\n\n @branch = Branch.new branch_params.except(*[:lat, :lng]).merge(coordinates: [branch_params[:lng], branch_params[:lat]])\n @branch.bussiness_id = current_user.bussiness.id\n if @branch.save\n render 'show.json.jbuilder', status: :created\n else\n render json: @branch.errors, status: :bad_request\n end\n end",
"def bitcoin\n @bitcoin_data = {\n price: @api_hash[\"RAW\"][\"BTC\"][\"USD\"][\"PRICE\"],\n change_usd: @api_hash[\"RAW\"][\"BTC\"][\"USD\"][\"CHANGE24HOUR\"].round(2),\n change_percent: @api_hash[\"RAW\"][\"BTC\"][\"USD\"][\"CHANGEPCT24HOUR\"].round(2)\n }\nend",
"def stock_bidask_with_http_info(symbol, opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: DefaultApi.stock_bidask ...'\n end\n # verify the required parameter 'symbol' is set\n if @api_client.config.client_side_validation && symbol.nil?\n fail ArgumentError, \"Missing the required parameter 'symbol' when calling DefaultApi.stock_bidask\"\n end\n # resource path\n local_var_path = '/stock/bidask'\n\n # query parameters\n query_params = opts[:query_params] || {}\n query_params[:'symbol'] = symbol\n\n # header parameters\n header_params = opts[:header_params] || {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n\n # form parameters\n form_params = opts[:form_params] || {}\n\n # http body (model)\n post_body = opts[:body] \n\n # return_type\n return_type = opts[:return_type] || 'LastBidAsk' \n\n # auth_names\n auth_names = opts[:auth_names] || ['api_key']\n\n new_options = opts.merge(\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => return_type\n )\n\n data, status_code, headers = @api_client.call_api(:GET, local_var_path, new_options)\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: DefaultApi#stock_bidask\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def create\n Wallet.transaction do \n @service = Service.find(params[:account_entry][:service_id]) ##@wallet.account_entries.build(params[:account_entry])\n @account_entry = @wallet.buy_smartbucks(@service)\n respond_to do |format|\n if @account_entry.pending?\n flash[:notice] = 'Transaction queued for processing'\n format.html { redirect_to(profile_wallet_path(@profile)) }\n format.mobile { redirect_to(profile_wallet_path(@profile)) }\n format.xml { render :xml => @account_entry, :status => :created, :location => @account_entry }\n else\n format.html { render :action => \"new\" }\n format.mobile { render :action => \"new\" }\n format.xml { render :xml => @account_entry.reason, :status => :unprocessable_entity }\n end\n end\n end\n end",
"def create\n @bike_rack = BikeRack.new(bike_rack_params)\n\n respond_to do |format|\n if @bike_rack.save\n flash[:success] = 'Bike rack was successfully created.'\n format.html { redirect_to @bike_rack }\n format.json { render :show, status: :created, location: @bike_rack }\n else\n flash[:danger] = 'There was a problem with creating Bike rack.'\n format.html { render :new }\n format.json { render json: @bike_rack.errors, status: :unprocessable_entity }\n end\n end\n end",
"def pay\n @order = Order.find(params[:id])\n end",
"def bay_params\n params.require(:bay).permit(:nomenclatura, :battery_bank_id, :lightning_arrester_id, :reactor_id, :substation_id, :switch_id, :transformer_id, blade_ids: [])\n end",
"def pay_now\n order = current_order || raise(ActiveRecord::RecordNotFound)\n session[:order_number] = current_order.number\n invoice = order.place_bitpay_order(notificationURL: api_bitpay_notification_url , redirectURL: DOMAIN+\"/confirm_order/reviewOrder\")\n @invoice_iframe_url = \"#{invoice['url']}\"\n render json: @invoice_iframe_url.to_json\n end",
"def save_kit(params)\n # separate the ID from the other params\n id = params['id']\n params.reject! { |k,v| k == 'id' }\n\n resp = @api.save_kit(params, id)\n @io.display_kit_info resp\n # return the id so a queued operation can continue operating on this kit\n id\n end",
"def bike_params\n params.require(:bike).permit(:status, :miles, :last_fix)\n end",
"def save(options = nil)\n request = Request.new(@client)\n path = \"/products/\" + CGI.escape(@id) + \"\"\n data = {\n \"name\"=> @name, \n \"amount\"=> @amount, \n \"currency\"=> @currency, \n \"metadata\"=> @metadata, \n \"request_email\"=> @request_email, \n \"request_shipping\"=> @request_shipping, \n \"return_url\"=> @return_url, \n \"cancel_url\"=> @cancel_url\n }\n\n response = Response.new(request.put(path, data, options))\n return_values = Array.new\n \n body = response.body\n body = body[\"product\"]\n \n \n return_values.push(self.fill_with_data(body))\n \n\n \n return_values[0]\n end",
"def charge_bill_source bill_src_id, bill_id, amount\n url = 'https://%s:@api.omise.co/charges' % [ ENV['OMISE_SECRET_KEY'] ]\n api_uri = URI.parse(url)\n # must convert amout to satang\n data = {'amount' => (amount * 100).to_i.to_s, 'currency' => 'thb', 'source' => bill_src_id.to_s,\n 'description' => 'Charge for bill id ' + bill_id.to_s}\n puts data\n res = Net::HTTP.post_form(api_uri, data)\n case res\n when Net::HTTPSuccess, Net::HTTPRedirection\n # OK\n puts res.body\n JSON.parse res.body\n else\n puts res.body\n puts res.error!\n\n nil\n end\n end",
"def create\n @bill_point = BillPoint.new(params[:bill_point])\n\n respond_to do |format|\n if @bill_point.save\n format.html { redirect_to @bill_point, notice: 'Bill point was successfully created.' }\n format.json { render json: @bill_point, status: :created, location: @bill_point }\n else\n format.html { render action: \"new\" }\n format.json { render json: @bill_point.errors, status: :unprocessable_entity }\n end\n end\n end",
"def post_address\n postcode = params['value'].delete('- ')\n address = CoreService.get_address(postcode)\n\n respond_to do |format|\n format.json { render json: { success: true, address: address } }\n end\n end",
"def create\n @brave_burst = BraveBurst.new(brave_burst_params)\n\n respond_to do |format|\n if @brave_burst.save\n format.html { redirect_to @brave_burst, notice: 'Brave burst was successfully created.' }\n format.json { render action: 'show', status: :created, location: @brave_burst }\n else\n format.html { render action: 'new' }\n format.json { render json: @brave_burst.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @order = Order.new(order_params)\n @drink = Drink.where(drink: @order.drink).first\n if @drink.nil?\n respond_to do |format|\n format.json { render json: {}, status: 404}\n end\n else\n respond_to do |format|\n if @order.save\n @drink = Drink.where(drink: @order.drink).first\n format.html { redirect_to @order, notice: 'Order was successfully created.' }\n response_json = {drink: @drink.drink, cost: @drink.cost, _links: { next: {profile: \"http://#{my_address}:3000/payment\", href: \"http://#{my_address}:3000/payments/order/#{@order.id}\", enctype: 'application/json'}}}\n format.json { render json: response_json, status: :created, location: @order }\n else\n format.html { render action: 'new' }\n format.json { render json: @order.errors, status: :unprocessable_entity }\n end\n end\n end\n end",
"def action_point_bd(input)\n token = params[:xml][:FromUserName]\n card_info = Card.where(:utoken=>token,:isbinded=>true).order('updated_at desc').first\n if !card_info.nil? && card_info[:validatedate]<Time.now\n card_info = Card.renew_card token\n end\n #persist user request\n log_use_request {|request|\n request.lastaction = RequestAction::ACTION_JF_SEARCH_BD\n }\n return build_response_text_temp {|msg|\n msg.Content = t(:successmsgtemplate2).sub('[point]',card_info['point'].to_s)\n } if !card_info.nil?\n\n return build_response_text_temp {|msg|\n msg.Content = t(:notbindinghelp)\n }\n end"
] |
[
"0.5836549",
"0.57249355",
"0.564266",
"0.5571774",
"0.55488956",
"0.54904217",
"0.5476726",
"0.5394052",
"0.534504",
"0.5344305",
"0.5341261",
"0.5325098",
"0.5282314",
"0.52753234",
"0.52706754",
"0.5238265",
"0.5228178",
"0.52144134",
"0.52126336",
"0.51975065",
"0.518727",
"0.5181273",
"0.517236",
"0.5156724",
"0.51309186",
"0.51254696",
"0.51219165",
"0.5121156",
"0.51185536",
"0.51099575",
"0.50945234",
"0.5092669",
"0.50874066",
"0.50799406",
"0.5075455",
"0.5075138",
"0.5048184",
"0.5045709",
"0.5040973",
"0.5026734",
"0.50200605",
"0.5013049",
"0.50107193",
"0.5005786",
"0.49862403",
"0.49843228",
"0.49804205",
"0.49747747",
"0.49688664",
"0.4950193",
"0.49405527",
"0.49254662",
"0.4923112",
"0.49227688",
"0.4918137",
"0.49163246",
"0.49086374",
"0.49064636",
"0.4906116",
"0.48976672",
"0.48935354",
"0.48887616",
"0.48872754",
"0.4886573",
"0.48692358",
"0.48659584",
"0.48644623",
"0.48601973",
"0.48586994",
"0.48586443",
"0.48581702",
"0.48522857",
"0.48434156",
"0.4842046",
"0.48408213",
"0.48266762",
"0.4818148",
"0.4817566",
"0.48153904",
"0.48141447",
"0.48113775",
"0.48104486",
"0.4810131",
"0.48100406",
"0.4805713",
"0.48053333",
"0.48052716",
"0.48051697",
"0.4804492",
"0.48009235",
"0.4799065",
"0.479685",
"0.47943622",
"0.4786419",
"0.4786112",
"0.47811896",
"0.47741038",
"0.47725168",
"0.4772334",
"0.47723067"
] |
0.54679114
|
7
|
return view page create a slide
|
def create
@mode = 'I'
render 'admin/slides/slide'
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def new\n @page_slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page_slide }\n end\n end",
"def show\n @slides =@lecture.slides(params[:urlpage])\n \n end",
"def show\n @contents = @slide.contents\n end",
"def show\n session[:slideshow] = @slideshow\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n end",
"def show_slide\n @slide = @slideshow.slides[session[:slide_index]]\n session[:slide_index] += 1\n if @slide.nil?\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n end\n render partial: \"show_slides\"\n end",
"def show_slide\n @slideshow = session[:slideshow]\n session[:slide_index] += 1\n @slide = @slideshow.slides[session[:slide_index]]\n if @slide == nil\n session[:slide_index] = 0\n @slide = @slideshow.slides[session[:slide_index]]\n end\n render :partial => \"show_slide\"\n end",
"def new\n @web_slide = WebSlide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @web_slide }\n end\n end",
"def slideshow\n self\n end",
"def slide\n slde = { start_date: mk_date(start_year),\n end_date: mk_date((end_year.presence || start_year)),\n text: mk_text(body, name) }\n if image.attached?\n slde['media'] = { url: cover_url.to_s,\n link: url }\n end\n slde\n end",
"def new\n @slideshow = Slideshow.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @slideshow }\n end\n end",
"def new\n @slideshow = Slideshow.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @slideshow }\n end\n end",
"def create\n @page_slide = Slide.new(params[:page_slide])\n\n respond_to do |format|\n if @page_slide.save\n format.html { redirect_to @page_slide, notice: 'Slide was successfully created.' }\n format.json { render json: @page_slide, status: :created, location: @page_slide }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page_slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_slide\n @slide = @presentation.slides.friendly.find(params[:id]) \n end",
"def new\n return false if !userCan :slide\n @slide = Slide.new\n @items = Item.find(:all, :order => \"position\")\n @agendas= Agenda.find(:all, :order => \"position\")\n @projectors = Projector.all\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def new\n @slide_type = SlideType.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @slide_type }\n end\n end",
"def new\n @slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def new\n @slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def new\n @slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def new\n @pslide = Pslide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @pslide }\n end\n end",
"def show\n @page_slide = Slide.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page_slide }\n end\n end",
"def show\n @slideshow = Slideshow.find(params[:id])\n session[:slideshow] = @slideshow\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n\n#respond_to do |format|\n# format.html # show.html.erb\n# format.xml { render :xml => @slideshow }\n# end\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def index\n @slides = Slide.paginate(:page => 1, :per_page => 10)\n @page = 'slides'\n end",
"def shareview\n # set default\n @template = 'slideshow_customv3'\n if @view_options.has_key?(params[:v].to_i) \n @template = 'slideshow_customv'+ params[:v] \n end\n # the main share view\n # pulls in the child view\n render 'shareshow' \n \n end",
"def show\n @web_slide = WebSlide.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @web_slide }\n end\n end",
"def set_slide\n @slide = Slide.nondraft.find(params[:id])\n end",
"def index\n #@deck = Powerpoint::Presentation.new\n # Creating an introduction slide:\n # title = 'Bicycle Of the Mind'\n # subtitle = 'created by Steve Jobs'\n # @deck.add_intro title, subtitle\n\n # Creating a text-only slide:\n # Title must be a string.\n # Content must be an array of strings that will be displayed as bullet items.\n # title = 'Why Mac?'\n # content = ['Its cool!', 'Its light.']\n # @deck.add_textual_slide title, content\n\n # Creating an image Slide:\n # It will contain a title as string.\n # and an embeded image\n #title = 'Everyone loves Macs:'\n #subtitle = 'created by Steve Jobs'\n #content = ['Its cool!', 'Its light.']\n #image_path = ActionController::Base.helpers.asset_path('/app/assets/images/ss.png').to_s\n #image = view_context.image_path 'ss.png'\n #url = 'http://localhost:3000' + image\n #image = view_context.image_path 'https://res.cloudinary.com/indoexchanger/image/upload/v1501168483/qxbvro2yhvibid0ra5rp.jpg'\n #puts image\n #@deck.add_pictorial_slide title, url\n #@deck.add_textual_slide title, subtitle\n #\n\n # Specifying coordinates and image size for an embeded image.\n # x and y values define the position of the image on the slide.\n # cx and cy define the width and height of the image.\n # x, y, cx, cy are in points. Each pixel is 12700 points.\n # coordinates parameter is optional.\n # coords = {x: 124200, y: 3356451, cx: 2895600, cy: 1013460}\n # @deck.add_pictorial_slide title, image_path, coords\n\n # Saving the pptx file to the current directory.\n #@deck.save('mps.pptx')\n # @products = Product.all\n # \n \n @presentation = RubySlides::Presentation.new\n \n chart_title = \"Chart Slide exported from ruby\"\n chart_series = [\n {\n column: \"Col1\",\n rows: [\"Lorem\", \"Ipsum\", \"Dolar\", \"Ismet\"],\n values: [\"1\", \"3\", \"5\", \"7\"]\n },\n {\n column: \"Col2\",\n color: 'FF9800',\n rows: [\"A\", \"B\", \"C\", \"D\"],\n values: [\"2\", \"4\", \"6\", \"8\"]\n }\n ]\n @presentation.chart_slide chart_title, chart_series\n\n @presentation.save('mps.pptx')\n\n @products = Product.order('created_at DESC')\n respond_to do |format|\n format.html\n format.xlsx {\n response.headers['Content-Disposition'] = 'attachment; filename=\"all_products.xlsx\"'\n }\n end\n end",
"def create\n @slide = Slide.new(slide_params)\n @slide.presentation = @presentation\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to location: presentation_slides_url(@presentation), notice: 'Slide was successfully created.' }\n format.json { render action: 'show', status: :created, location: @slide }\n else\n format.html { render action: 'new' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n newparams = coerce(params) \n @slide = Slide.new(newparams[:slide])\n @slide.name = @slide.image_file_name\n @slide.position = @slide.presentation.slides.count + 1\n if @slide.save\n flash[:notice] = \"Successfully created slide.\"\n respond_to do |format| \n format.html {redirect_to @slide.presentation} \n format.json { render :json => { :result => 'success', :slide => slide_url(@slide) } }\n end\n else\n render :action => 'new'\n end\n end",
"def index\n @contents = @slide.contents\n redirect_to new_presentation_slide_content_path(@presentation, @slide) unless @contents.any?\n end",
"def index\n @slides = Slide.all\n end",
"def create\n @slide = Slide.new(params[:slide])\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to @slide, notice: 'Slide was successfully created.' }\n format.json { render json: @slide, status: :created, location: @slide }\n else\n format.html { render action: \"new\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def create\n @slide = Slide.new(params[:slide])\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to slides_url, notice: '幻灯片创建成功.' }\n format.json { render json: @slide, status: :created, location: @slide }\n else\n format.html { render action: \"new\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @slideshows = Slideshow.all\n @pag_url = '/slideshows/reload_pag'\n @page = 'home'\n end",
"def create\n @web_slide = WebSlide.new(params[:web_slide])\n\n respond_to do |format|\n if @web_slide.save\n format.html { redirect_to(@web_slide, :notice => 'Web slide was successfully created.') }\n format.xml { render :xml => @web_slide, :status => :created, :location => @web_slide }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @web_slide.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n\n @slide = Slide.new(slide_params)\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to [:admin, @slide], notice: 'Slide was successfully created.' }\n format.json { render action: 'show', status: :created, location: @slide }\n else\n format.html { render action: 'new' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def create\n @slide = Slide.new(slide_params)\n respond_to do |format|\n if @slide.save\n @slide.take_screenshot\n @slide.create_activity(:create, owner: current_user, parameters: { name: @slide.menu_name })\n current_user.slides << @slide\n format.html { redirect_to edit_slide_path(@slide) }\n format.json { render :show, status: :created, location: @slide }\n else\n format.html { render :new }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def google_slide_show(feed, \n content_id = 'slide_show_content',\n options = { :displayTime => 2000, :transistionTime => 600, :scaleImages => true, :fullControlPanel => true })\n render :partial => 'google/slide_show', :locals => { :feed => feed, :content_id => content_id, :options => options }\n end",
"def new\n @rss_slide = RssSlide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @rss_slide }\n end\n end",
"def create\n @slide = Slide.new(slide_params)\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to @slide, notice: \"Slide was successfully created.\" }\n format.json { render :show, status: :created, location: @slide }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @slides_grid = initialize_grid(Slide,:per_page => 10)\n end",
"def create(url=\"\")\n if url.present?\n @slideshow = Slideshow.new\n @slideshow.name = url\n else\n @slideshow = Slideshow.new(params[:slideshow])\n end\n @slideshow.slide_order_hash = {}\n respond_to do |format|\n \n if @slideshow.save\n format.html { \n redirect_to(\"/#{@slideshow.name}/new\", :notice => 'Slideshow was successfully created.') } #CONSTRUCTION, finish this path after completing routes\n \n #format.html { redirect_to(new_slideshow_slide_path(@slideshow), :notice => 'Slideshow was successfully created.') }\n format.xml { render :xml => @slideshow, :status => :created, :location => @slideshow }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @slideshow.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def show\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @slide }\n end\n end",
"def show\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @slide }\n end\n end",
"def show\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @slide }\n end\n end",
"def new\n @title = t('view.slides.new_title')\n @slide = @lesson.slides.build\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def slide(dir)\n @row, @col = slide_pos(dir)\n make_king\n nil\n end",
"def index\n @tbl_slides = TblSlide.all\n session[:fromeditpage]=0\n session[:fromslides]=1\n\n\n\n end",
"def page\n\n end",
"def new\n @slideshow = Slideshow.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slideshow }\n end\n end",
"def new\n @slideshow = Slideshow.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slideshow }\n end\n end",
"def new\n @promo_slide = PromoSlide.new\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @promo_slide }\n end\n end",
"def show\n @slide_type = SlideType.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @slide_type }\n end\n end",
"def show\n @event = Event.find params[:id]\n @slides = @event.slides.page(params[:page]).per(10)\n end",
"def page; end",
"def page; end",
"def page; end",
"def page; end",
"def page; end",
"def page; end",
"def page; end",
"def page; end",
"def page; end",
"def page; end",
"def page; end",
"def page; end",
"def show\n page_name, page_ext = get_page_path\n page = ComatosePage.find_by_path( page_name )\n status = nil\n if page.nil?\n page = ComatosePage.find_by_path( '404' )\n status = 404\n end\n # if it's still nil, well, send a 404 status\n if page.nil?\n render :nothing=>true, :status=>status\n #raise ActiveRecord::RecordNotFound.new(\"Comatose page not found \")\n else\n # Make the page access 'safe' \n @page = Comatose::PageWrapper.new(page)\n # For accurate uri creation, tell the page class which is the active mount point...\n ComatosePage.active_mount_info = get_active_mount_point(params[:index])\n render :text=>page.to_html({'params'=>params.stringify_keys}), :layout=>get_page_layout, :status=>status\n end\n end",
"def play\n @selected_slide_key = @interface.current_slide.short_name\n respond_to do |format|\n format.html { render :play, layout: 'etm' }\n format.js\n end\n end",
"def page\n PageDrop.new(@page, page)\n end",
"def create\n @title = t('view.slides.new_title')\n @slide = @lesson.slides.build slide_params\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to(course_lesson_url(@lesson.course, @lesson, anchor: @slide.anchor), notice: t('view.slides.correctly_created')) }\n format.json { render json: @slide, status: :created, location: @slide }\n else\n format.html { render action: 'new' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n render :layout => \"presentation\"\n end",
"def show\n @page = find_or_create_page\n @presenter = Presenters::PagePresenter.new(@page, self.class.helpers)\n respond_with(@page)\n end",
"def index\n self.get_slide_index\n end",
"def index\n @slides = Slide.paginate(:page => params[:page], :per_page => 10).order('id DESC').accessible_by(current_ability)\n end",
"def show\n @presentation = Presentation.find_by_name(params[:prez_id])\n @pslide = Pslide.find(params[:id])\n @pcontent=Array.new\n @pbehavior=Pbehavior.new\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @pslide }\n end\n end",
"def slides\n @id = params[:id]\n @item = Item.find(@id)\n begin\n @slides = @item.images.where(['publish=?', true]).order('position')\n rescue => error\n flash[:error] = error.message\n ensure\n # no slides found so create some\n if @slides.empty?\n @slides = @item.create_images\n end\n end\n unless @id.nil? || @slides.nil? || @slides.empty?\n respond_to do |format|\n format.xml\n end\n else\n flash[:error] = 'Unable to locate process slides for id number ' + params[:id].to_s + '.'\n end\n end",
"def create\n @slideshow = Slideshow.new(params[:slideshow])\n\n respond_to do |format|\n if @slideshow.save\n format.html { redirect_to(@slideshow, :notice => 'Slideshow was successfully created.') }\n format.xml { render :xml => @slideshow, :status => :created, :location => @slideshow }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @slideshow.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def show\n @carousel_slides = @carousel.carousel_slides\n end",
"def set_slide\n @slide = Slide.where(id: params[:id]).accessible_by(current_ability).take\n end",
"def set_slideshow\n @slideshow = Slideshow.find(params[:id])\n end",
"def set_slideshow\n @slideshow = Slideshow.find(params[:id])\n end",
"def new\n @presentation = Presentation.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @presentation }\n end\n end",
"def index\n @slideshows = Slideshow.all\n end",
"def show\n # render :layout => 'presentation'\n end",
"def create\n @slide = Slide.new(params[:slide])\n\n # If we're creating a new slide from the slideshow editing page, add the\n # slide to the slideshow and then redirect to the slideshow edit screen.\n @slide.slideshows << (@slideshow = Slideshow.find(params[:slideshow_id])) if params[:slideshow_id]\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to (@slideshow ? edit_slideshow_path(@slideshow) : @slide), notice: 'Slide was successfully created.' }\n format.json { render json: @slide, status: :created, location: @slide }\n else\n format.html { render action: \"new\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @rss_slide = RssSlide.new(params[:rss_slide])\n\n respond_to do |format|\n if @rss_slide.save\n format.html { redirect_to(@rss_slide, :notice => 'Rss slide was successfully created.') }\n format.xml { render :xml => @rss_slide, :status => :created, :location => @rss_slide }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @rss_slide.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n inform = Inform.find(params[:inform_id])\n slide = inform.slides.build(slide_params)\n slide.user_id = current_user.id\n\n if slide.save\n redirect_to inform, notice: 'La placa ha sido creada exitosamente.'\n else\n render :new\n end\n end",
"def view()\n @view\n end",
"def page(name, options = {})\n options[:layout] = true unless options.has_key?(:layout)\n view(name, options)\n end",
"def set_post_slide\n @post_slide = PostSlide.find(params[:id])\n end",
"def create\n @promo_slide = PromoSlide.new(promo_slide_params)\n respond_to do |format|\n if @promo_slide.save\n format.html { redirect_to @promo_slide, notice: 'Promo slide was successfully created.' }\n format.json { render json: @promo_slide, status: :created, location: @promo_slide }\n else\n format.html { render action: \"new\" }\n format.json { render json: @promo_slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @ppage = Podpage.new\n end",
"def new\n @slide_image = SlideImage.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide_image }\n end\n end",
"def slideshow_frame(slide, position=0)\n hidden = (position == 0) ? \"\" : \"display:none\"\n slide_link = (slide.string_value =~ /^\\// || slide.string_value =~ /^http/i) ? slide.string_value : \"/#{params[:locale]}/#{slide.string_value}\"\n\n target = (slide.text_value.to_s.match(/new.window|blank|new.tab/i)) ? \"_blank\" : \"\"\n slide_content = (slide.string_value.blank?) ?\n image_tag(slide.slide.url, lazy: false) :\n link_to(image_tag(slide.slide.url, lazy: false), slide_link, target: target)\n\n if p = website.value_for('countdown_overlay_position')\n if p == position && cd = website.value_for('countdown_container')\n slide_content += content_tag(:div, '', id: cd)\n end\n end\n\n content_tag(:div, slide_content, id: \"slideshow_#{(position + 1)}\", class: \"slideshow_frame\", style: hidden)\n\n end"
] |
[
"0.69299203",
"0.6904884",
"0.6800734",
"0.67499614",
"0.6744819",
"0.667199",
"0.6669424",
"0.66220504",
"0.66192925",
"0.6611391",
"0.6611391",
"0.66070235",
"0.65402",
"0.65184635",
"0.6500471",
"0.6487202",
"0.6487202",
"0.6487202",
"0.64664435",
"0.64406675",
"0.64167476",
"0.63620013",
"0.6312073",
"0.62836397",
"0.62793666",
"0.62691593",
"0.6267397",
"0.62546086",
"0.6250502",
"0.62421376",
"0.6230425",
"0.62256855",
"0.62239194",
"0.62239194",
"0.62239194",
"0.62239194",
"0.62239194",
"0.6199621",
"0.6190648",
"0.61772525",
"0.61407256",
"0.6138043",
"0.6111601",
"0.61108845",
"0.6100865",
"0.60934144",
"0.6092498",
"0.60720015",
"0.6057934",
"0.6057934",
"0.6057934",
"0.60575837",
"0.60538286",
"0.60407794",
"0.60372466",
"0.60249466",
"0.60249466",
"0.60064095",
"0.60041195",
"0.59911686",
"0.5989029",
"0.5989029",
"0.5989029",
"0.5989029",
"0.5989029",
"0.5989029",
"0.5989029",
"0.5989029",
"0.5989029",
"0.5989029",
"0.5989029",
"0.5989029",
"0.5981918",
"0.5980623",
"0.5979885",
"0.5962575",
"0.59460884",
"0.5946046",
"0.59384257",
"0.5929588",
"0.5927542",
"0.59264094",
"0.5925805",
"0.59214056",
"0.5913835",
"0.590975",
"0.590975",
"0.5903396",
"0.5893552",
"0.58931404",
"0.5887519",
"0.5870413",
"0.5864344",
"0.5848006",
"0.58418566",
"0.58394074",
"0.58259785",
"0.58208346",
"0.58136135",
"0.580473"
] |
0.75595266
|
0
|
return view page edit a slide
|
def edit
@data = SlidesHlp.getSlide(params[:id])
if @data['slide_vi'] == nil
@mode = 'I'
else
@slide = @data['slide_vi']
@slide_ja = @data['slide_ja']
@lang = @data['lang']
@mode = 'U'
end
render 'admin/slides/slide'
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_slide\n @slide = @presentation.slides.friendly.find(params[:id]) \n end",
"def set_slide\n @slide = Slide.nondraft.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def create\n @mode = 'I'\n render 'admin/slides/slide'\n end",
"def show\n @slides =@lecture.slides(params[:urlpage])\n \n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def show_slide\n @slide = @slideshow.slides[session[:slide_index]]\n session[:slide_index] += 1\n if @slide.nil?\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n end\n render partial: \"show_slides\"\n end",
"def show\n @contents = @slide.contents\n end",
"def show_slide\n @slideshow = session[:slideshow]\n session[:slide_index] += 1\n @slide = @slideshow.slides[session[:slide_index]]\n if @slide == nil\n session[:slide_index] = 0\n @slide = @slideshow.slides[session[:slide_index]]\n end\n render :partial => \"show_slide\"\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def show\n session[:slideshow] = @slideshow\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n end",
"def set_slide\n @slide = Slide.where(id: params[:id]).accessible_by(current_ability).take\n end",
"def update\n @page_slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @page_slide.update_attributes(params[:page_slide])\n format.html { redirect_to page_slide_url(@page_slide.page, @page_slide), notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page_slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_main_slide\n @main_slide = MainSlide.find(params[:id])\n end",
"def show\n @page_slide = Slide.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page_slide }\n end\n end",
"def show\n @web_slide = WebSlide.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @web_slide }\n end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to presentation_slide_url(@presentation, @slide), notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_post_slide\n @post_slide = PostSlide.find(params[:id])\n end",
"def show\n @slide_type = SlideType.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @slide_type }\n end\n end",
"def new\n return false if !userCan :slide\n @slide = Slide.new\n @items = Item.find(:all, :order => \"position\")\n @agendas= Agenda.find(:all, :order => \"position\")\n @projectors = Projector.all\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n @inf = @slide.inform_id\n end",
"def update\n respond_to do |format|\n if UpdateSlide.execute(@slide, slide_params, current_user)\n @slide.take_screenshot\n @slide.create_activity(:update, owner: current_user, parameters: { name: @slide.menu_name })\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @slideshow = Slideshow.find(params[:id])\n session[:slideshow] = @slideshow\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n\n#respond_to do |format|\n# format.html # show.html.erb\n# format.xml { render :xml => @slideshow }\n# end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to [:admin, @slide], notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to :back, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n\t\t@page_name = \" - Edit Show\"\n\tend",
"def saveSlide\n if params[:mode] == 'I'\n update = SlidesHlp.saveSlide(params[:slide])\n else\n update = SlidesHlp.updateSlide(params[:slide])\n end\n render json: update\n end",
"def editing ; view.editing ; end",
"def update\n @slide = Slide.find(params[:id])\n @slide.name = params[:slide][:name] unless params[:slide][:name].nil?\n @slide.position = params[:slide][:position] unless params[:slide][:position].nil?\n if @slide.update_attributes(params[:slide])\n flash[:notice] = \"Successfully updated slide.\"\n redirect_to @slide.presentation\n else\n render :action => 'edit'\n end\n end",
"def edit\n @page = Page.find(params[:id])\n # render edit.html.erb\n end",
"def edit\n @page = Page.find(params[:id])\n # render :edit - app/views/pages/\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to \"/slides\", notice: 'slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @web_slide = WebSlide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @web_slide }\n end\n end",
"def show\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @slide }\n end\n end",
"def show\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @slide }\n end\n end",
"def show\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @slide }\n end\n end",
"def toggle_edit_present_slide_url(slide_url)\n # Identifying whether it is a SlideUrl in presentation mode or Edit mode\n present_matchers = slide_url.match(\"/present#slide\")\n\n case slide_url.match(/\\/(present|edit)(#|\\?)/).to_s\n when \"/present#\"\n return slide_url.gsub(\"/present#\", \"/edit#\")\n when \"/present?\"\n # return slide_url.gsub(\"/present?\", \"/edit#\")\n uri = Addressable::URI.parse(slide_url.gsub('/present?', '/edit?'))\n query_values = uri.query_values || {}\n uri.fragment = \"slide=\" + query_values.delete('slide') if query_values.present?\n uri.query_values = query_values.present? ? query_values : nil\n return uri.to_s\n when \"/edit#\", \"/edit?\"\n return slide_url.gsub(/\\/edit(#|\\?)/, \"/present?\")\n else\n return nil\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n @page = Page.find(params[:id])\n #render :edit - app/views/pages/edit.html.erb\n end",
"def edit\n @page = Page.find(params[:id])\n #render the edit form\n end",
"def edit\n redirect_to wizard_path(steps[0])\n end",
"def index\n @contents = @slide.contents\n redirect_to new_presentation_slide_content_path(@presentation, @slide) unless @contents.any?\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to @slide, notice: \"Slide was successfully updated.\" }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @agenda = Agenda.find(params[:id])\n @slides= @agenda.slides\n @slide= @slides[0] if @slides.count == 1 and !params[:slide]\n @slide= Slide.find(params[:slide]) if params[:slide]\n @menu_edit_link = (\"<a href='\"+edit_agenda_path(@agenda)+\"'>Edit</a>\").html_safe if userCould :agendas\n\n if ((userCould :slide) or (userCould :projector)) and !@slide.nil? then\n @menu_cmd_link = '<a id=\"drop1\" href=\"#\" role=\"button\" class=\"dropdown-toggle\" data-toggle=\"dropdown\">Slide<b class=\"caret\"></b></a><ul class=\"dropdown-menu\" role=\"menu\" aria-labelledby=\"drop2\">'\n Projector.all.each{|p|\n @menu_cmd_link += '<li><a href=\"#\" onclick=\\'$.post(\"'+(url_for p)+'\", { \"command[cmd]\": \"load\", \"command[slide]\": \"'+@slide.id.to_s+'\", \"authenticity_token\" : \"'+form_authenticity_token+'\"} );\\'>Auf Beamer '+p.name+'</a></li>' \n }if userCould :projector\n @menu_cmd_link += '<li><a href=\"'+edit_slide_path(@slide)+'\">Bearebieten</a></li>' if userCould :slide\n @menu_cmd_link += '</ul>'\n @menu_cmd_link = @menu_cmd_link.html_safe\n end\n\n @load_push = true\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @agenda }\n end\n end",
"def edit\n respond_with(page)\n end",
"def show\n redirect_to presentation_survey_path(params[:presentation_id], params[:survey_id])\n end",
"def play\n @selected_slide_key = @interface.current_slide.short_name\n respond_to do |format|\n format.html { render :play, layout: 'etm' }\n format.js\n end\n end",
"def open\n @item = Image.find(params[:id])\n @sslaunch = '<script>reslide();</script>';\n render :partial => 'layouts/om', :locals => {:@item => @item, :@sslaunch => @sslaunch}\n end",
"def new\n @page_slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page_slide }\n end\n end",
"def index\n @tbl_slides = TblSlide.all\n session[:fromeditpage]=0\n session[:fromslides]=1\n\n\n\n end",
"def slide_url_mode(slide_url)\n return :edit if slide_url.match(/\\/edit(#|\\?)/)\n return :presentation if slide_url.match(/\\/present(#|\\?)/)\n end",
"def edit\n @page = Page.find(params[:id])\n end",
"def edit\n @page = Page.find(params[:id])\n end",
"def get_presentation\n if params[:presentation_id].present?\n @presentation = Presentation.find params[:presentation_id]\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to slides_url, notice: '幻灯片修改成功.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @slide_type = SlideType.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @slide_type }\n end\n end",
"def show\n @title = t('view.slides.show_title')\n @slide = @lesson.slides.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @slide }\n end\n end",
"def show\n @event = Event.find params[:id]\n @slides = @event.slides.page(params[:page]).per(10)\n end",
"def set_presentation\n @presentation = Presentation.find(params[:id])\n end",
"def new\n @pslide = Pslide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @pslide }\n end\n end",
"def set_presentation\n @presentation = Presentation.find(params[:presentation_id])\n end",
"def set_slideshow\n @slideshow = Slideshow.find(params[:id])\n end",
"def set_slideshow\n @slideshow = Slideshow.find(params[:id])\n end",
"def set_presentationdetail\n @presentationdetail = Presentationdetail.find(params[:id])\n end",
"def update\n @title = t('view.slides.edit_title')\n @slide = @lesson.slides.find(params[:id])\n\n respond_to do |format|\n if @slide.update slide_params\n format.html { redirect_to(course_lesson_url(@lesson.course, @lesson, anchor: @slide.anchor), notice: t('view.slides.correctly_updated')) }\n format.json { head :ok }\n else\n format.html { render action: 'edit' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n\n rescue ActiveRecord::StaleObjectError\n redirect_to edit_lesson_slide_url(@lesson, @slide), alert: t('view.slides.stale_object_error')\n end",
"def new\n @slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def new\n @slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def new\n @slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def edit\n # Clear the page cache for this page... ?\n @page = Comatose::Page.find_is_snippet params[:id]\n if request.post?\n @page.update_attributes(params[:page])\n @page.updated_on = Time.now\n @page.author = current_user\n if @page.valid? && @page.save\n expire_cms_page @page\n expire_cms_fragment @page\n flash[:notice] = \"Saved changes to '#{@page.title}'\"\n redirect_to :controller=>self.controller_name, :action=>'index'\n end\n \n end\n end",
"def index\n @slides = Slide.all\n end",
"def update\n @pslide = Pslide.find(params[:id])\n\n respond_to do |format|\n if @pslide.update_attributes(params[:pslide])\n format.html { redirect_to @pslide, notice: 'Pslide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @pslide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @web_slide = WebSlide.find(params[:id])\n\n respond_to do |format|\n if @web_slide.update_attributes(params[:web_slide])\n format.html { redirect_to(@web_slide, :notice => 'Web slide was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @web_slide.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @slideshow = Slideshow.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @slideshow }\n end\n end",
"def new\n @slideshow = Slideshow.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @slideshow }\n end\n end",
"def update\n return false if !userCan :slide\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n if params[:projector_add] then\n params[:projector_add].each {|v|\n Projector.find(v).update_attributes(:slide_id => params[:id]);\n Message.Command(:id => \"projector-#{v}\", :cmd => \"load\", :slide => params[:id])\n }\n end\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n @user = current_user\n @presentation = Presentation.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @promo_slide.update(promo_slide_params)\n format.html { redirect_to @promo_slide, notice: 'Promo slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @promo_slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_promo_slide\n @promo_slide = PromoSlide.find(params[:id])\n end",
"def index\n @slideshows = Slideshow.all\n @pag_url = '/slideshows/reload_pag'\n @page = 'home'\n end",
"def edit_slideshow username, password, slideshow_id, options = {}\n do_request 'edit_slideshow', options.merge(username: username, password: password,\n slideshow_id: slideshow_id)\n end",
"def show\n @presentation = Presentation.find_by_name(params[:prez_id])\n @pslide = Pslide.find(params[:id])\n @pcontent=Array.new\n @pbehavior=Pbehavior.new\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @pslide }\n end\n end",
"def show_old\n # enable_light_box\n @item = @current_user.project.items.find params[:id]\n #@item.section.project.update_attribute(:open_section, @item.section_id) # @item.reviewd!\n return redirect_to introduction_section_path(@item.section) unless @item.section.is_intro_viewed\n if @item.preceding.class == Section\n if @item.preceding.do_show_intro\n @preceding = introduction_section_path(@item.preceding)\n else\n @preceding = item_path(@item.preceding.preceding)\n end\n else\n @preceding = item_path(@item.preceding)\n end\n if @item.following.class == Section\n if @item.following.do_show_intro\n @following = introduction_section_path(@item.following)\n else\n @following = item_path(@item.following.following)\n end\n else\n @following = item_path(@item.following)\n end\n @item.reviewed!\n render :layout => false\n end",
"def edit\n @wiki_page = WikiPage.find(params[:wiki_page_id])\n redirect_to edit_url(@wiki_page,params[:id])\n end",
"def preview\n end",
"def preview\n end",
"def edit\n render\n end",
"def edit\n render\n end",
"def slideshow\n self\n end",
"def index\n @slides = Slide.paginate(:page => 1, :per_page => 10)\n @page = 'slides'\n end",
"def shareview\n # set default\n @template = 'slideshow_customv3'\n if @view_options.has_key?(params[:v].to_i) \n @template = 'slideshow_customv'+ params[:v] \n end\n # the main share view\n # pulls in the child view\n render 'shareshow' \n \n end",
"def index\n @slides = Slide.paginate(:page => params[:page], :per_page => 10).order('id DESC').accessible_by(current_ability)\n end",
"def view()\n @view\n end",
"def set_ppt\n @presentation = Presentation.find(params[:id])\n end",
"def view\n\n @view_only = true\n\n wid = params[:id]\n\n return error_wi_not_found \\\n unless OpenWFE::Extras::Workitem.exists?(wid)\n\n load_workitem wid\n\n render :template => \"workitem/edit\"\n end",
"def edit\n \n end"
] |
[
"0.72954106",
"0.7116887",
"0.71042323",
"0.7039532",
"0.69894713",
"0.6987289",
"0.6987289",
"0.6987289",
"0.6987289",
"0.6987289",
"0.69081426",
"0.68734515",
"0.6873193",
"0.68410283",
"0.6732529",
"0.6664729",
"0.66635966",
"0.65734047",
"0.6557006",
"0.6555633",
"0.6544821",
"0.6536836",
"0.6526826",
"0.6523064",
"0.6513683",
"0.650961",
"0.6497209",
"0.6492814",
"0.6480078",
"0.6465999",
"0.6459005",
"0.64493936",
"0.6442874",
"0.64355487",
"0.64101106",
"0.64040875",
"0.63770485",
"0.6367011",
"0.6353432",
"0.6353432",
"0.6353432",
"0.6352052",
"0.63506544",
"0.6346197",
"0.63303155",
"0.62918407",
"0.6277257",
"0.62719",
"0.6263138",
"0.62518543",
"0.62515366",
"0.6245243",
"0.6244888",
"0.62382257",
"0.6230409",
"0.62153053",
"0.6194957",
"0.6194957",
"0.6175495",
"0.6175334",
"0.61739206",
"0.6168619",
"0.6166353",
"0.61635995",
"0.6154426",
"0.61412513",
"0.61322033",
"0.61322033",
"0.6129752",
"0.6114795",
"0.6101786",
"0.6101786",
"0.6101786",
"0.6092942",
"0.6090918",
"0.6089686",
"0.6087858",
"0.6067416",
"0.6067416",
"0.6058525",
"0.60442513",
"0.60411954",
"0.6038278",
"0.6030051",
"0.60282123",
"0.60154057",
"0.60130054",
"0.60029685",
"0.5996362",
"0.5996362",
"0.59958625",
"0.59958625",
"0.5985956",
"0.5984438",
"0.598344",
"0.59814656",
"0.5979257",
"0.59562194",
"0.59480786",
"0.59348124"
] |
0.77079725
|
0
|
get data translate of slide
|
def referSlide
result = Hash.new
result['status'] = true
begin # try
result['data'] = Slide.find_by( id: params[:id], lang: params[:lang], deleted_at: nil)
rescue # catch
result['status'] = false
result['error'] = "#{$!}"
ensure # finally
render json: result
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def return_slide_and_data\n target_sentence = nil\n loop do\n target_word = @enrolment_manager.next_word\n return { service: 'EMPTY' } if target_word.nil?\n target_sentence = @next_sentence_retriever.retrieve(target_word)\n break if target_sentence.present?\n @enrolment_manager.assign_status(target_word, EXHAUSTED)\n end\n SlideConstructor.new(@enrolment_manager, target_sentence).construct\n end",
"def translate(p1, p2, p3, d)\r\n v = p3 - p2\r\n v.length = d\r\n trans=Geom::Transformation.translation(v)\r\n return p1.transform(trans)\r\n end",
"def translate(p1, p2, p3, d)\r\n v = p3 - p2\r\n v.length = d\r\n trans=Geom::Transformation.translation(v)\r\n return p1.transform(trans)\r\n end",
"def translate(p1, p2, p3, d)\r\n v = p3 - p2\r\n v.length = d\r\n trans=Geom::Transformation.translation(v)\r\n return p1.transform(trans)\r\n end",
"def get_trans_hash\n@transition\nend",
"def translations; end",
"def get_title_from_slide_text(slide_text)\n\n end",
"def translate(x, y = 0)\n current_transformation.translate(x, y)\n self[\"transform\"] = current_transformation.to_s\n end",
"def slide\n { start_date: mk_date,\n end_date: mk_date,\n group: key_point.scripted.name,\n text: mk_text(summary, name) }\n end",
"def get(x,y)\n # Translate, bottom left ist 0,0\n y = (height-1) - y\n \n @data[y][x]\n end",
"def translation\n @translation ||= name.underscore.split('/').last\n end",
"def label_translation; end",
"def show\n @translate\n @uploaded_text = ''\n translation_map = []\n end",
"def translate(x, y = 0)\n transform[:translate] = [x, y]\n end",
"def translation\n @translation ||= Mongify::Translation.parse(@translation_file)\n end",
"def original\n @original ||= @container[:translation].original\n end",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def get_translation \n if self.source_name == \"ENSEMBLPEP\"\n self.genome_db.connect_to_genome\n return Ensembl::Core::Translation.find_by_stable_id(self.stable_id)\n else\n return nil\n end\n end",
"def original_to_translation(language, original)\n\t\t\t\t\t\tload_cache(language)\n\t\t\t\t\t\treturn @o2t[language.to_sym][original.to_s]\n\t\t\t\t\tend",
"def transformation\n end",
"def get_dictionary_translation html_doc\n translations = Array.new\n translation = html_doc.xpath(\"//span[@id='result_box']\")\n translation.each do |t|\n add_translation t.text\n end\n translations\n end",
"def fetch_translated_law\n\n con = Faraday.new\n\n res = con.post do |req|\n req.url 'https://api.deepl.com/v2/translate?auth_key='+ ENV[\"DEEPL_API\"],\n req.body = {text: self.name,\n target_lang: 'EN',\n source_lang: 'FR'\n }\n end\n self.translatedtext = JSON.parse(res.body)[\"translations\"][1][\"text\"]\n end",
"def translations\n OneclickRefernet::Translation.where(key: self.code)\n end",
"def translations\n if self.sentence_axis\n sentence_axis.sentences.to_a - [self]\n else\n []\n end\n end",
"def text\n # if the title is not present, show the code\n get_translation(self.text_translations, self.dataset.current_locale, self.dataset.default_language)\n end",
"def migrate(data)\n keys = I18n::Translate.hash_to_keys(data, @translate.options[:separator])\n keys.each do |key|\n entry = I18n::Translate.find(key, data, @translate.options[:separator])\n next unless I18n::Translate.is_enhanced?(entry)\n %w(old t).each do |prop|\n next unless entry[prop]\n value = entry.delete(prop)\n prop = case(prop)\n when \"old\"\n \"old_default\"\n when \"t\"\n \"translation\"\n end\n entry[prop] = value\n end\n I18n::Translate.set(key, entry, data, @translate.options[:separator])\n end\n data\n end",
"def source\n @source ||= {}\n @source[Locomotive::Mounter.locale] ||= self.template.need_for_prerendering? ? self.template.render : self.template.data\n end",
"def translate(settings); end",
"def transforms\n @transforms ||= []\n end",
"def translate(response)\n end",
"def translation_to_original(language, translation)\n\t\t\t\t\t\tload_cache(language)\n\t\t\t\t\t\treturn @t2o[language.to_sym][translation.to_s]\n\t\t\t\t\tend",
"def translate(item)\n @progress.setMainStatusAndLogIt('Translating')\n text = get_original_text(item)\n return nil if text.empty?\n\n translated = ms_translate(text)\n super(item, translated) unless translated.nil? || translated.empty?\n end",
"def translate(point={})\n set RGhost::Cursor.translate(point)\n end",
"def get_translation(language)\n lang = language.to_s\n @current_translation ||= self.translations.in_language(lang).first\n if (!@current_translation.nil?) and (@current_translation[self.language_column] != lang) then\n @current_translation = self.translations.in_language(lang).first\n else\n @current_translation\n end\n end",
"def translate(key)\n read(key.to_s)\n end",
"def translatable\n self._translatable[base_name]\n end",
"def value(locale=I18n.locale)\n begin\n (self.setting_type =~ /slide/) ? self.slide : eval(\"self.#{self.setting_type}_value\")\n rescue\n nil\n end\n end",
"def get_text(to_translate)\n return send(*to_translate) if to_translate.is_a?(Array)\n return to_translate\n end",
"def data\n attributes['data']\n end",
"def translate(text, options = {})\n response = google_api_call(text,\"#{SERVICE}#{@from}%7C#{@to}#{TEXT_PAR}\",TranslationResponse)\n translation = options[:html] ? response.translation : CGI.unescapeHTML(response.translation)\n translation # return value\n end",
"def get_value(render_context)\n return @message.translate(render_context)\n end",
"def transforms; end",
"def lang\n\t\t\t@data[\"lang\"]\n\t\tend",
"def translate(x, y, &rendering_code); end",
"def text\n\t\t\t@data[\"extract\"]\n\t\tend",
"def translate_button(element)\n haml_tag :p, { source: element, class: 'translate btn', style: 'margin: 10px 0 10px 0'} do\n haml_tag :span, {class: 'translate_text'} do\n haml_concat t('kabupaten.translate')\n end\n haml_tag :span, {class: 'untranslate_text', style: 'display:none'} do\n haml_concat t('kabupaten.original_text')\n end\n haml_tag :span, {class: 'original_text', style: 'display:none'}\n haml_tag :span, {class: 'translated_text', style: 'display:none'}\n end\n end",
"def get_translation_label(step_type, key)\n json_data = get(url: \"#{@url}services/nexpose/metadata/#{step_type}\")\n\n target_hash = json_data[:labels].values.find { |label_hash| label_hash.has_key?(key) }\n target_hash[key] if target_hash\n end",
"def fetch_attribute(locale, name)\r\n translation = record.translation_for(locale)\r\n return translation && translation.send(name)\r\n end",
"def text\n # if the title is not present, show the code\n x = get_translation(self.text_translations, self.time_series.current_locale, self.time_series.default_language)\n return x.present? ? x : self.original_code\n end",
"def show\n @contents = @slide.contents\n end",
"def translate(*args, **opts); end",
"def get_translated_attributes(language_code)\n\n ::Model::Translation::TranslationTerm.find_translations_by_language(translation.id, language_code)\n\n end",
"def inline_translations_for(language)\n translations_for(language, -50)\n end",
"def data\n @datas\n end",
"def translate(text,dictonary)\nend",
"def pt( *args )\n translation = ft[ name ]\n args.empty? ? translation : translation[ *args, self ]\n end",
"def translations_hash; end",
"def updateSlideTrans\n result = Hash.new\n result['status'] = true\n begin # try\n if !SlidesHlp.updateSlideTrans(params[:slide])\n result['status'] = false\n end\n rescue # catch\n result['status'] = false\n result['error'] = \"#{$!}\"\n ensure # finally\n render json: result\n end\n end",
"def position_translate(i)\n i * 2 + 1\n end",
"def get_data()\t\n\tend",
"def data\n @data\n end",
"def data\n @data\n end",
"def data\n @data\n end",
"def data\n @data\n end",
"def transformed(p)\r\n (0..1).map do |i|\r\n (p[i] - @old_center[i])*@zoom + (@center[i] - @old_center[i])*@zoom + @old_center[i]\r\n end\r\n end",
"def translations\n\t\t\tvalues(\"http://scta.info/property/hasTranslation\")\n\t\tend",
"def transformations; end",
"def translate(word)\n @dataset.select(:en, :ru).where(en: word).or(ru: word)\n end",
"def get_translations\n I18n.translate(:foo) # Need to do this to force I18n init\n I18n.backend.send(:translations)\n end",
"def set_slide\n @slide = @presentation.slides.friendly.find(params[:id]) \n end",
"def x\n @data[:x]\n end",
"def data\n attributes.fetch(:data)\n end",
"def data\n attributes.fetch(:data)\n end",
"def apply_custom_transformation\n end",
"def data\n self[:data]\n end",
"def get_txt_panneau\n\t\treturn [mdl_par.panneaux[0].to_s,mdl_par.panneaux[1].to_s]\n\tend",
"def translation(locale=nil)\n return translation_for(:value, locale)\n end",
"def translate!( *args )\n super( *args )\n reset_positions_inside\n end",
"def get_translated_attributes(language_code)\n \n Model::Translation::TranslationTerm.find_translations_by_language(translation.id, language_code)\n \n end",
"def translateX(x)\n return x - @camX\n end",
"def trans(i)\r\n ((i) == -1 ? @rl_point : ((i) == -2 ? @rl_end : (i)))\r\n end",
"def trans(coord)\n\treturn [coord[0]+600, -coord[1]+350]\nend",
"def get_translate(locale, key)\r\n I18n.t!(key, :locale => locale)\r\n rescue\r\n nil\r\n end",
"def extract_translations(translation)\n @stanzas.flat_map {|s| s.stanza_translations.select { |st| st.translation_id == translation.id } }\n end",
"def set_transform\n @transform = Transform.find(params[:id])\n end",
"def data\n self.load if @data.nil?\n @data\n end",
"def translate(x)\n return 2 * x + 1\n end",
"def translate(attribute, locale_tag)\n if locale = DataMapper::I18n::Locale.for(locale_tag)\n t = resource.translations.first(:locale => locale)\n t ? t.send(attribute) : nil\n else\n nil\n end\n end",
"def export(data, indent=0)\n target = data[@translate.lang]\n xml = <<EOF\n<?xml version=\"1.0\" encoding=\"#{@translate.options[:encoding]}\"?>\n<!DOCTYPE TS>\n<TS version=\"2.0\" language=\"#{@translate.lang}\">\nEOF\n\n keys = I18n::Translate.hash_to_keys(target).sort\n keys.each do |key|\n value = @translate.find(key, target)\n next unless value\n\n if value.kind_of?(String) || value.kind_of?(Array) || value.kind_of?(Integer)\n fuzzy = (value.to_s.empty?) ? %~ type=\"unfinished\"~ : \"\"\n xml += <<EOF\n <context>\n <name>#{::CGI.escapeHTML(key)}</name>\n <message>\n <source>#{::CGI.escapeHTML(@translate.find(key, @translate.default).to_s)}</source>\n <translation#{fuzzy}>#{::CGI.escapeHTML(value.to_s)}</translation>\n </message>\n </context>\nEOF\n else\n fuzzy = ((value[\"flag\"] == \"ok\") or value[\"flag\"].to_s.strip.empty?) ? \"\" : (value[\"flag\"] == \"obsolete\") ? %~ type=\"obsolete\"~ : %~ type=\"unfinished\"~\n xml += <<EOF\n <context>\n <name>#{::CGI.escapeHTML(key)}</name>\n <message>\nEOF\n if value[\"file\"] or value[\"line\"]\n xml += <<EOF\n <location filename=\"#{::CGI.escapeHTML(value[\"file\"].to_s)}\" line=\"#{::CGI.escapeHTML(value[\"line\"].to_s)}\" />\nEOF\n end\n xml += <<EOF\n <source>#{::CGI.escapeHTML(value[\"default\"].to_s)}</source>\nEOF\n unless value[\"old_default\"].to_s.empty?\n xml += <<EOF\n <oldsource>#{::CGI.escapeHTML(value[\"old_default\"].to_s)}</oldsource>\nEOF\n end\n unless value[\"extracted_comment\"].to_s.empty?\n xml += <<EOF\n <extracomment>#{::CGI.escapeHTML(value[\"extracted_comment\"].to_s)}</extracomment>\nEOF\n end\n unless value[\"comment\"].to_s.empty?\n xml += <<EOF\n <translatorcomment>#{::CGI.escapeHTML(value[\"comment\"].to_s)}</translatorcomment>\nEOF\n end\n xml += <<EOF\n <translation#{fuzzy}>#{::CGI.escapeHTML(value[\"translation\"].to_s)}</translation>\nEOF\n unless value[\"flag\"].to_s.strip.empty?\n xml += <<EOF\n <extra-po-flags>#{::CGI.escapeHTML(value[\"flag\"].to_s.strip)}</extra-po-flags>\nEOF\n end\n xml += <<EOF\n </message>\n </context>\nEOF\n end\n end\n\n xml += <<EOF\n</TS>\nEOF\n xml\n end",
"def translated_words\n translated_words_list = []\n\n words.each do |word|\n translation_for_this_word = TranslatedWord.find_by_word_id(word.id)\n\n if translation_for_this_word.nil?\n translated_words_list << word.text # the original word text\n else\n translated_words_list << translation_for_this_word.translation\n end\n end\n\n translated_words_list\n end",
"def generate_field_translations options\n params_hash = direct_translate_to_html(options)\n if options['locale'].to_sym == :de\n params_hash['source'] = 'researcher'\n else\n params_hash = GoogleTranslateCommunicator.get_translations(\n params_hash, options['locale']\n )\n params_hash['source'] = 'GoogleTranslate'\n end\n params_hash\n end",
"def data\n @data\n end",
"def data\n @data\n end"
] |
[
"0.56755507",
"0.55818",
"0.55818",
"0.55785453",
"0.5513553",
"0.54947346",
"0.5453491",
"0.53896767",
"0.53681326",
"0.52934486",
"0.5283824",
"0.5269602",
"0.52453387",
"0.5234027",
"0.52149826",
"0.52055985",
"0.5189202",
"0.5189202",
"0.5189202",
"0.5189202",
"0.5189202",
"0.5189202",
"0.5189202",
"0.5189202",
"0.51436865",
"0.5137187",
"0.5121213",
"0.51090497",
"0.5093142",
"0.5091671",
"0.50799966",
"0.50776136",
"0.50757354",
"0.5010949",
"0.5009457",
"0.5007713",
"0.497667",
"0.49444982",
"0.4923661",
"0.49201792",
"0.49015254",
"0.48978332",
"0.48973927",
"0.48918054",
"0.48891157",
"0.4888031",
"0.4887032",
"0.48860264",
"0.48832685",
"0.4869283",
"0.48634562",
"0.4862265",
"0.48546356",
"0.485116",
"0.4843218",
"0.48367608",
"0.48338747",
"0.48251757",
"0.48246822",
"0.48216742",
"0.4795922",
"0.4794584",
"0.478821",
"0.47871447",
"0.47833288",
"0.47755465",
"0.47680542",
"0.4764203",
"0.4764203",
"0.4764203",
"0.47481912",
"0.4747259",
"0.47378886",
"0.47372186",
"0.47344533",
"0.47310707",
"0.47254342",
"0.47192073",
"0.47191706",
"0.47191706",
"0.4716841",
"0.47134674",
"0.47021985",
"0.47007933",
"0.47002983",
"0.4697771",
"0.46908423",
"0.4688751",
"0.46847153",
"0.46817464",
"0.46809256",
"0.46768337",
"0.46652365",
"0.46593228",
"0.4658151",
"0.46567804",
"0.46475512",
"0.4646047",
"0.46433783",
"0.46433783"
] |
0.4973316
|
37
|
add or update a slide
|
def saveSlide
if params[:mode] == 'I'
update = SlidesHlp.saveSlide(params[:slide])
else
update = SlidesHlp.updateSlide(params[:slide])
end
render json: update
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = @presentation.slides.friendly.find(params[:id]) \n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.nondraft.find(params[:id])\n end",
"def create\n @mode = 'I'\n render 'admin/slides/slide'\n end",
"def set_next_slide\n if self.sequence-1>=1\n @slide=Slide.find_by_sequence_and_presentation_id(self.sequence-1,self.presentation_id)\n @slide.next_slide=self.id\n @slide.save\n end\n end",
"def push(slide)\n n = to_a.size + 1\n # Paths within the zip file of new files we have to write.\n slide_path = Pathname.new(\"/ppt/slides/slide#{n}.xml\")\n slide_rels_path = Pathname.new(\"/ppt/slides/_rels/slide#{n}.xml.rels\")\n slide_notes_path = Pathname.new(\"/ppt/notesSlides/notesSlide#{n}.xml\")\n slide_notes_rels_path = Pathname.new(\"/ppt/notesSlides/_rels/notesSlide#{n}.xml.rels\")\n\n # Update ./ppt\n # !!! CREATE !!!\n # ./slides\n # Create new files\n # ./slide(\\d+).xml file\n @doc.copy slide_path, slide.path\n # ./_rels/slide(\\d+).xml.rels\n @doc.copy slide_rels_path, slide.rels.path\n # ./notesSlides\n # Create new files\n # ./notesSlide(\\d+).xml file\n @doc.copy slide_notes_path, slide.notes.path\n # ./_rels/notesSlide(\\d+).xml.rels\n @doc.copy slide_notes_rels_path, slide.notes.rels.path\n \n # !!! UPDATES !!!\n # Update the notes in the new slide to point at the new notes\n @doc.edit_xml slide_rels_path do |xml|\n # TODO - Move this rel logic into the parts so that we don't have to repeat ourselves when calculating this stuff out.\n xml.at_xpath(\"//xmlns:Relationship[@Type='#{Notes::REL_TYPE}']\")['Target'] = slide_notes_path.relative_path_from(slide_path.dirname)\n end\n\n # Update teh slideNotes reference to point at the new slide\n @doc.edit_xml slide_notes_rels_path do |xml|\n xml.at_xpath(\"//xmlns:Relationship[@Type='#{Slide::REL_TYPE}']\")['Target'] = slide_path.relative_path_from(slide_notes_path.dirname)\n end\n\n # ./_rels/presentation.xml.rels\n # Update Relationship ids\n # Insert a new one slideRef\n @doc.edit_xml @doc.presentation.rels.path do |xml|\n # Calucate the next id\n next_id = xml.xpath('//xmlns:Relationship[@Id]').map{ |n| n['Id'] }.sort.last.succ\n # TODO - Figure out how to make this more MS idiomatic up 9->10 instead of incrementing\n # the character....\n # Insert that into the slide and crakc open the presentation.xml file\n types = xml.at_xpath('/xmlns:Relationships')\n types << Nokogiri::XML::Node.new(\"Relationship\", xml).tap do |n|\n n['Id'] = next_id\n n['Type'] = Slide::REL_TYPE\n n['Target'] = slide_path.relative_path_from(@doc.presentation.path.dirname)\n end\n # ./presentation.xml\n # Update attr\n # p:notesMasterId\n # Insert attr\n # p:sldId, increment, etc.\n @doc.edit_xml '/ppt/presentation.xml' do |xml|\n slides = xml.at_xpath('/p:presentation/p:sldIdLst')\n next_slide_id = slides.xpath('//p:sldId[@id]').map{ |n| n['id'] }.sort.last.succ\n slides << Nokogiri::XML::Node.new(\"p:sldId\", xml).tap do |n|\n # TODO - Fix the ID that's jacked up.\n n['id'] = next_slide_id\n n['r:id'] = next_id\n end\n end\n end\n\n # Update ./[Content-Types].xml with new slide link and slideNotes link\n @doc.edit_xml @doc.content_types.path do |xml|\n types = xml.at_xpath('/xmlns:Types')\n types << Nokogiri::XML::Node.new(\"Override\", xml).tap do |n|\n n['PartName'] = slide_path\n n['ContentType'] = Slide::CONTENT_TYPE\n end\n types << Nokogiri::XML::Node.new(\"Override\", xml).tap do |n|\n n['PartName'] = slide_notes_path\n n['ContentType'] = Notes::CONTENT_TYPE\n end\n end\n\n # Great, that's all done, so lets return the slide eh?\n slide slide_path\n end",
"def add_slide(slide_name, collection, insert_before_slide, opts={})\n opts.merge!(name: slide_name, collection: collection, insert_before_slide: insert_before_slide)\n slide = Slide.new(opts, @slide_manager)\n @slides << slide\n\n yield(slide)\n end",
"def set_slide\n @slide = Slide.where(id: params[:id]).accessible_by(current_ability).take\n end",
"def update\n @slide = Slide.find(params[:id])\n @slide.name = params[:slide][:name] unless params[:slide][:name].nil?\n @slide.position = params[:slide][:position] unless params[:slide][:position].nil?\n if @slide.update_attributes(params[:slide])\n flash[:notice] = \"Successfully updated slide.\"\n redirect_to @slide.presentation\n else\n render :action => 'edit'\n end\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n @inf = @slide.inform_id\n end",
"def set_post_slide\n @post_slide = PostSlide.find(params[:id])\n end",
"def show_slide\n @slide = @slideshow.slides[session[:slide_index]]\n session[:slide_index] += 1\n if @slide.nil?\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n end\n render partial: \"show_slides\"\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to \"/slides\", notice: 'slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show_slide\n @slideshow = session[:slideshow]\n session[:slide_index] += 1\n @slide = @slideshow.slides[session[:slide_index]]\n if @slide == nil\n session[:slide_index] = 0\n @slide = @slideshow.slides[session[:slide_index]]\n end\n render :partial => \"show_slide\"\n end",
"def create\n @slide = Slide.new(params[:slide])\n\n # If we're creating a new slide from the slideshow editing page, add the\n # slide to the slideshow and then redirect to the slideshow edit screen.\n @slide.slideshows << (@slideshow = Slideshow.find(params[:slideshow_id])) if params[:slideshow_id]\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to (@slideshow ? edit_slideshow_path(@slideshow) : @slide), notice: 'Slide was successfully created.' }\n format.json { render json: @slide, status: :created, location: @slide }\n else\n format.html { render action: \"new\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to :back, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to @slide, notice: \"Slide was successfully updated.\" }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if UpdateSlide.execute(@slide, slide_params, current_user)\n @slide.take_screenshot\n @slide.create_activity(:update, owner: current_user, parameters: { name: @slide.menu_name })\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n return false if !userCan :slide\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n if params[:projector_add] then\n params[:projector_add].each {|v|\n Projector.find(v).update_attributes(:slide_id => params[:id]);\n Message.Command(:id => \"projector-#{v}\", :cmd => \"load\", :slide => params[:id])\n }\n end\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n\n @slide = Slide.new(slide_params)\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to [:admin, @slide], notice: 'Slide was successfully created.' }\n format.json { render action: 'show', status: :created, location: @slide }\n else\n format.html { render action: 'new' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slideshow = @user.slideshows.find(params[:id])\n @user.slideshows << @slideshow\n\n respond_to do |format|\n if @slideshow.update_attributes(params[:slideshow])\n format.html { redirect_to @slideshow, notice: 'Slideshow was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slideshow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @slide = Slide.new(slide_params)\n respond_to do |format|\n if @slide.save\n @slide.take_screenshot\n @slide.create_activity(:create, owner: current_user, parameters: { name: @slide.menu_name })\n current_user.slides << @slide\n format.html { redirect_to edit_slide_path(@slide) }\n format.json { render :show, status: :created, location: @slide }\n else\n format.html { render :new }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to slides_url, notice: '幻灯片修改成功.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_slideshow\n @slideshow = Slideshow.find(params[:id])\n end",
"def set_slideshow\n @slideshow = Slideshow.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to presentation_slide_url(@presentation, @slide), notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to [:admin, @slide], notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def perform_slide(move)\n raise IllegalMoveError.new unless slides.include? move\n\n perform_move(move)\n end",
"def set_main_slide\n @main_slide = MainSlide.find(params[:id])\n end",
"def show\n session[:slideshow] = @slideshow\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n end",
"def create\n newparams = coerce(params) \n @slide = Slide.new(newparams[:slide])\n @slide.name = @slide.image_file_name\n @slide.position = @slide.presentation.slides.count + 1\n if @slide.save\n flash[:notice] = \"Successfully created slide.\"\n respond_to do |format| \n format.html {redirect_to @slide.presentation} \n format.json { render :json => { :result => 'success', :slide => slide_url(@slide) } }\n end\n else\n render :action => 'new'\n end\n end",
"def create\n @slide = Slide.new(slide_params)\n @slide.presentation = @presentation\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to location: presentation_slides_url(@presentation), notice: 'Slide was successfully created.' }\n format.json { render action: 'show', status: :created, location: @slide }\n else\n format.html { render action: 'new' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def append_slide(master_slide_name, arguments = {})\n raise ArgumentError.new \"nil master_slide_name is given\" unless master_slide_name\n\n result = eval_script <<-APPLE.unindent\n var Keynote = Application(\"Keynote\")\n var doc = Keynote.documents.byId(\"#{self.id}\")\n var masterSlide = doc.masterSlides.whose({name: \"#{master_slide_name}\"}).first\n var slide = Keynote.Slide({ baseSlide: masterSlide })\n doc.slides.push(slide)\n slide = doc.slides()[doc.slides().length - 1]\n\n var slideResult = {\n body_showing: slide.bodyShowing(),\n skipped: slide.skipped(),\n slide_number: slide.slideNumber(),\n title_showing: slide.titleShowing(),\n default_body_item: slide.defaultBodyItem(),\n default_title_item: slide.defaultTitleItem(),\n presenter_notes: slide.presenterNotes(),\n transition_properties: slide.transitionProperties()\n }\n JSON.stringify(slideResult)\n APPLE\n\n slide = Slide.new(\n base_slide: MasterSlide.new(master_slide_name),\n body_showing: result[\"body_showing\"],\n skipped: result[\"skipped\"],\n slide_number: result[\"slide_number\"],\n title_showing: result[\"title_showing\"],\n default_body_item: result[\"default_body_item\"],\n default_title_item: result[\"default_title_item\"],\n presenter_notes: result[\"presenter_notes\"],\n transition_properties: result[\"transition_properties\"],\n )\n @slides << slide\n end",
"def create\n @slide = Slide.new(params[:slide])\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to @slide, notice: 'Slide was successfully created.' }\n format.json { render json: @slide, status: :created, location: @slide }\n else\n format.html { render action: \"new\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slideshow = Slideshow.find(params[:id])\n\n @slideshow.slides += params[:add_slides].map{ |es| Slide.find(es) } if params[:add_slides]\n\n @slideshow.slideshow_slides.where(:slide_id => params[:del_slides]).delete_all\n\n respond_to do |format|\n if @slideshow.update_attributes(params[:slideshow])\n format.js { render :nothing => true }\n format.html { redirect_to (params[:existing_slides] ? edit_slideshow_path(@slideshow) : @slideshow), notice: 'Slideshow was successfully updated.' }\n format.json { head :no_content }\n else\n format.js { render :nothing => true }\n format.html { render action: \"edit\" }\n format.json { render json: @slideshow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page_slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @page_slide.update_attributes(params[:page_slide])\n format.html { redirect_to page_slide_url(@page_slide.page, @page_slide), notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page_slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n return false if !userCan :slide\n @slide = Slide.new(params[:slide])\n\n respond_to do |format|\n if @slide.save\n if params[:projector_add] then\n params[:projector_add].each {|v|\n Projector.find(v).update_attributes(:slide_id => params[:id]);\n Message.Command(:id => \"projector-#{v}\", :cmd => \"load\", :slide => params[:id])\n }\n end\n format.html { redirect_to @slide, notice: 'Slide was successfully created.' }\n format.json { render json: @slide, status: :created, location: @slide }\n else\n format.html { render action: \"new\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_promo_slide\n @promo_slide = PromoSlide.find(params[:id])\n end",
"def create\n @slide = Slide.new(slide_params)\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to @slide, notice: \"Slide was successfully created.\" }\n format.json { render :show, status: :created, location: @slide }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def next_slide()\n if @current_slide < @total_slides - 1\n @current_slide += 1\n end\n end",
"def set_slideshow\n @slideshow = Slideshow.find_by_uid(params[:id].downcase)\n end",
"def create\n @slide = Slide.new(params[:slide])\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to slides_url, notice: '幻灯片创建成功.' }\n format.json { render json: @slide, status: :created, location: @slide }\n else\n format.html { render action: \"new\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_slider\n @slider = Slider.find(params[:id])\n end",
"def slide\n slde = { start_date: mk_date(start_year),\n end_date: mk_date((end_year.presence || start_year)),\n text: mk_text(body, name) }\n if image.attached?\n slde['media'] = { url: cover_url.to_s,\n link: url }\n end\n slde\n end",
"def update\n @pslide = Pslide.find(params[:id])\n\n respond_to do |format|\n if @pslide.update_attributes(params[:pslide])\n format.html { redirect_to @pslide, notice: 'Pslide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @pslide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n inform = Inform.find(params[:inform_id])\n slide = inform.slides.build(slide_params)\n slide.user_id = current_user.id\n\n if slide.save\n redirect_to inform, notice: 'La placa ha sido creada exitosamente.'\n else\n render :new\n end\n end",
"def show\n @contents = @slide.contents\n end",
"def update\n slideshow_params.delete(:slides_to_add)\n slides_to_add_ids = params[:slideshow][:slides_to_add]\n slides_to_remove_ids = params[:slideshow][:slides_to_remove]\n\n if slides_to_remove_ids.present?\n slides_to_remove = Slide.find(slides_to_remove_ids.values)\n slides_to_remove.each do |slide|\n @slideshow.slide_entries.select { |e| e.slide_id == slide.id }.each do |se|\n se.delete\n end\n end\n end\n\n\n if slides_to_add_ids.present?\n slides_to_add = Slide.find(slides_to_add_ids.values)\n slides_to_add.each do |slide|\n se = SlideEntry.new(:slide_id => slide.id, :slideshow_id => @slideshow.id)\n se.save!\n end\n end\n\n if @slideshow.update(slideshow_params)\n render :partial => 'slideshow_list_sect', :locals => { :slideshows => current_user.slideshows.paginate(:page => params[:page]), :context_page => 'account', :pag_url => '/slideshows/reload_pag_user' }\n else\n render :partial => 'slideshow_list_sect', :locals => { :slideshows => current_user.slideshows.paginate(:page => params[:page]), :context_page => 'account', :pag_url => '/slideshows/reload_pag_user' }\n flash[:error] = \"Error Updating: #{@slideshow.errors.full_messages}\"\n end\n end",
"def updateShowSlide\n result = Hash.new\n result['status'] = true\n begin # try\n result['status'] = Slide.where(id: params[:id])\n .update_all('slides.show = NOT slides.show, updated_by = ' + $user_id.to_s + ', updated_at = \\'' + Time.now.to_formatted_s(:db) + '\\'')\n rescue # catch\n result['status'] = false\n result['error'] = \"#{$!}\"\n ensure # finally\n render json: result\n end\n end",
"def slides=(v)\n Axlsx.validate_int v\n @slides = v\n end",
"def slides\n @id = params[:id]\n @item = Item.find(@id)\n begin\n @slides = @item.images.where(['publish=?', true]).order('position')\n rescue => error\n flash[:error] = error.message\n ensure\n # no slides found so create some\n if @slides.empty?\n @slides = @item.create_images\n end\n end\n unless @id.nil? || @slides.nil? || @slides.empty?\n respond_to do |format|\n format.xml\n end\n else\n flash[:error] = 'Unable to locate process slides for id number ' + params[:id].to_s + '.'\n end\n end",
"def create\n @page_slide = Slide.new(params[:page_slide])\n\n respond_to do |format|\n if @page_slide.save\n format.html { redirect_to @page_slide, notice: 'Slide was successfully created.' }\n format.json { render json: @page_slide, status: :created, location: @page_slide }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page_slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @title = t('view.slides.edit_title')\n @slide = @lesson.slides.find(params[:id])\n\n respond_to do |format|\n if @slide.update slide_params\n format.html { redirect_to(course_lesson_url(@lesson.course, @lesson, anchor: @slide.anchor), notice: t('view.slides.correctly_updated')) }\n format.json { head :ok }\n else\n format.html { render action: 'edit' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n\n rescue ActiveRecord::StaleObjectError\n redirect_to edit_lesson_slide_url(@lesson, @slide), alert: t('view.slides.stale_object_error')\n end",
"def setup_slide\n return unless PONY::ERRNO.check_sequence(current_act)\n stop_all_movements\n xpos = (flip && !@ignore_flip_point ? -@acts[1] : @acts[1])\n ypos = @acts[2]\n slide(xpos, ypos, @acts[3], @acts[4], @acts[5] || 0)\n @acts[4].times do\n method_wait\n end\n end",
"def create\n @title = t('view.slides.new_title')\n @slide = @lesson.slides.build slide_params\n\n respond_to do |format|\n if @slide.save\n format.html { redirect_to(course_lesson_url(@lesson.course, @lesson, anchor: @slide.anchor), notice: t('view.slides.correctly_created')) }\n format.json { render json: @slide, status: :created, location: @slide }\n else\n format.html { render action: 'new' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n @data = SlidesHlp.getSlide(params[:id])\n if @data['slide_vi'] == nil\n @mode = 'I'\n else\n @slide = @data['slide_vi']\n @slide_ja = @data['slide_ja']\n @lang = @data['lang']\n @mode = 'U'\n end\n render 'admin/slides/slide'\n end",
"def set_slideshow\n if !params[:id].nil?\n @slideshow = Slideshow.find(params[:id])\n else\n @slideshow = Slideshow.find(session[:slideshow][\"id\"])\n end\n end",
"def index\n #@deck = Powerpoint::Presentation.new\n # Creating an introduction slide:\n # title = 'Bicycle Of the Mind'\n # subtitle = 'created by Steve Jobs'\n # @deck.add_intro title, subtitle\n\n # Creating a text-only slide:\n # Title must be a string.\n # Content must be an array of strings that will be displayed as bullet items.\n # title = 'Why Mac?'\n # content = ['Its cool!', 'Its light.']\n # @deck.add_textual_slide title, content\n\n # Creating an image Slide:\n # It will contain a title as string.\n # and an embeded image\n #title = 'Everyone loves Macs:'\n #subtitle = 'created by Steve Jobs'\n #content = ['Its cool!', 'Its light.']\n #image_path = ActionController::Base.helpers.asset_path('/app/assets/images/ss.png').to_s\n #image = view_context.image_path 'ss.png'\n #url = 'http://localhost:3000' + image\n #image = view_context.image_path 'https://res.cloudinary.com/indoexchanger/image/upload/v1501168483/qxbvro2yhvibid0ra5rp.jpg'\n #puts image\n #@deck.add_pictorial_slide title, url\n #@deck.add_textual_slide title, subtitle\n #\n\n # Specifying coordinates and image size for an embeded image.\n # x and y values define the position of the image on the slide.\n # cx and cy define the width and height of the image.\n # x, y, cx, cy are in points. Each pixel is 12700 points.\n # coordinates parameter is optional.\n # coords = {x: 124200, y: 3356451, cx: 2895600, cy: 1013460}\n # @deck.add_pictorial_slide title, image_path, coords\n\n # Saving the pptx file to the current directory.\n #@deck.save('mps.pptx')\n # @products = Product.all\n # \n \n @presentation = RubySlides::Presentation.new\n \n chart_title = \"Chart Slide exported from ruby\"\n chart_series = [\n {\n column: \"Col1\",\n rows: [\"Lorem\", \"Ipsum\", \"Dolar\", \"Ismet\"],\n values: [\"1\", \"3\", \"5\", \"7\"]\n },\n {\n column: \"Col2\",\n color: 'FF9800',\n rows: [\"A\", \"B\", \"C\", \"D\"],\n values: [\"2\", \"4\", \"6\", \"8\"]\n }\n ]\n @presentation.chart_slide chart_title, chart_series\n\n @presentation.save('mps.pptx')\n\n @products = Product.order('created_at DESC')\n respond_to do |format|\n format.html\n format.xlsx {\n response.headers['Content-Disposition'] = 'attachment; filename=\"all_products.xlsx\"'\n }\n end\n end",
"def update_notes_slide(name, slide_index, dto, password = nil, folder = nil, storage = nil)\n data, _status_code, _headers = update_notes_slide_with_http_info(name, slide_index, dto, password, folder, storage)\n data\n end",
"def setup_slide\n return TSBS.error(@acts[0], 4, @used_sequence) if @acts.size < 5\n stop_all_movements\n xpos = (flip && !@ignore_flip_point ? -@acts[1] : @acts[1])\n ypos = @acts[2]\n slide(xpos, ypos, @acts[3], @acts[4], @acts[5] || 0)\n end",
"def slide_params\n params.require(:slide).permit(:name, :slides_to_add, :file)\n end",
"def set_presentation\n @presentation = Presentation.find(params[:id])\n end",
"def set_presentation\n @presentation = Presentation.find(params[:presentation_id])\n end",
"def update\n respond_to do |format|\n if @promo_slide.update(promo_slide_params)\n format.html { redirect_to @promo_slide, notice: 'Promo slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @promo_slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @rss_slide = RssSlide.find(params[:id])\n\n respond_to do |format|\n if @rss_slide.update_attributes(params[:rss_slide])\n format.html { redirect_to(@rss_slide, :notice => 'Rss slide was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @rss_slide.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def set_slider_depo\n @slider_depo = SliderDepo.find(params[:id])\n end",
"def new\n return false if !userCan :slide\n @slide = Slide.new\n @items = Item.find(:all, :order => \"position\")\n @agendas= Agenda.find(:all, :order => \"position\")\n @projectors = Projector.all\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def update\n @web_slide = WebSlide.find(params[:id])\n\n respond_to do |format|\n if @web_slide.update_attributes(params[:web_slide])\n format.html { redirect_to(@web_slide, :notice => 'Web slide was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @web_slide.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def set_tbl_slide\n @tbl_slide = TblSlide.find(params[:id])\n end",
"def update\n @slideshow = Slideshow.find(params[:id])\n\n respond_to do |format|\n if @slideshow.update_attributes(params[:slideshow])\n format.html { redirect_to @slideshow, notice: 'Slideshow was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slideshow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_roll\n @roll = Slider.find(params[:id])\n end",
"def set_slider_ad\n @slider_ad = SliderAd.find(params[:id])\n end",
"def slide\n slides.first rescue nil\n end",
"def create\n @slideshow = Slideshow.new(params[:slideshow])\n @user.slideshows << @slideshow\n\n respond_to do |format|\n if @slideshow.save\n format.html { redirect_to @slideshow, notice: 'Slideshow was successfully created.' }\n format.json { render json: @slideshow, status: :created, location: @slideshow }\n else\n format.html { render action: \"new\" }\n format.json { render json: @slideshow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def insert_image(path)\n execute_applescript('insert_image', slides_count, File.absolute_path(path), TEMPLATE_SLIDE_INDEX)\n end",
"def slide_params\n params.require(:slide).permit(:title, :header, :number, :body, :presentation_id)\n end",
"def update\n respond_to do |format|\n if @slider.update(slider_params)\n format.html { redirect_to action: :index, notice: 'Обновлено.' }\n format.json { render :index, status: :ok, location: @slider }\n else\n format.html { render :crop }\n format.json { render json: @slider.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_image_slider\n @image_slider = ImageSlider.find(params[:id])\n end",
"def update\n @slideshow = Slideshow.find(params[:id])\n\n respond_to do |format|\n if @slideshow.update_attributes(params[:slideshow])\n format.html { redirect_to(@slideshow, :notice => 'Slideshow was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @slideshow.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @slideshow = Slideshow.find(params[:id])\n\n respond_to do |format|\n if @slideshow.update_attributes(params[:slideshow])\n format.html { redirect_to(@slideshow, :notice => 'Slideshow was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @slideshow.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def slide_params\n params.require(:slide).permit(:title, :default, :position, :page_id, :slide)\n end",
"def new\n @slideshow = Slideshow.new\n @user.slideshows << @slideshow\n \n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slideshow }\n end\n end",
"def update\n respond_to do |format|\n if @slideshow.update(slideshow_params)\n format.html { redirect_to @slideshow, notice: 'Slideshow was successfully updated.' }\n format.json { render :show, status: :ok, location: @slideshow }\n else\n format.html { render :edit }\n format.json { render json: @slideshow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @slideshow.update(slideshow_params)\n format.html { redirect_to @slideshow, notice: 'Slideshow was successfully updated.' }\n format.json { render :show, status: :ok, location: @slideshow }\n else\n format.html { render :edit }\n format.json { render json: @slideshow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def slide(step)\n js_exec(\"$('.#{step}.owl-carousel').data('owlCarousel').next();\")\n end",
"def bubble_update\n\t\tslide_asset.bubble_update\n\tend",
"def new\n @slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def new\n @slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def new\n @slide = Slide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @slide }\n end\n end",
"def new\n @pslide = Pslide.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @pslide }\n end\n end",
"def set_presentation\n @presentation = Presentation.find(1)\n end",
"def setup_smooth_slide\n tx = @acts[1] + x || 0\n ty = @acts[2] + y || 0\n dur = @acts[3] || 25\n rev = @acts[4]\n rev = true if rev.nil?\n smooth_move(tx,ty,dur,rev)\n end"
] |
[
"0.70799494",
"0.7076021",
"0.7076021",
"0.7076021",
"0.7076021",
"0.7076021",
"0.7000752",
"0.6988983",
"0.69607586",
"0.6899706",
"0.67030966",
"0.6678957",
"0.6637103",
"0.6569969",
"0.6502856",
"0.6471711",
"0.6443339",
"0.64378774",
"0.6412726",
"0.6355204",
"0.63209397",
"0.63145053",
"0.62737167",
"0.6269433",
"0.6267459",
"0.6253205",
"0.62427735",
"0.6239948",
"0.6214151",
"0.61820626",
"0.6180312",
"0.6171301",
"0.6171301",
"0.6158653",
"0.61579776",
"0.61517197",
"0.61490107",
"0.6145607",
"0.6135226",
"0.61233413",
"0.610864",
"0.6091255",
"0.60691327",
"0.6061076",
"0.6059896",
"0.6058336",
"0.602755",
"0.6005794",
"0.6002171",
"0.5999551",
"0.5996816",
"0.5991854",
"0.5990188",
"0.5972862",
"0.59518814",
"0.5946849",
"0.5931488",
"0.5926939",
"0.592099",
"0.58738726",
"0.5853108",
"0.583796",
"0.57523996",
"0.57375646",
"0.5731954",
"0.5723018",
"0.5703234",
"0.5649555",
"0.5647599",
"0.56294745",
"0.5553782",
"0.5552294",
"0.5550026",
"0.55398643",
"0.5529131",
"0.5524484",
"0.55136645",
"0.5513342",
"0.55114853",
"0.55086607",
"0.55057436",
"0.55030465",
"0.55014473",
"0.54877037",
"0.54867935",
"0.5478846",
"0.5476815",
"0.5476815",
"0.54627955",
"0.5439375",
"0.5429747",
"0.5429747",
"0.541378",
"0.541264",
"0.5405189",
"0.5405189",
"0.5405189",
"0.54040766",
"0.54022086",
"0.54012203"
] |
0.6647529
|
12
|
update data translate of slide
|
def updateSlideTrans
result = Hash.new
result['status'] = true
begin # try
if !SlidesHlp.updateSlideTrans(params[:slide])
result['status'] = false
end
rescue # catch
result['status'] = false
result['error'] = "#{$!}"
ensure # finally
render json: result
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def migrate(data)\n keys = I18n::Translate.hash_to_keys(data, @translate.options[:separator])\n keys.each do |key|\n entry = I18n::Translate.find(key, data, @translate.options[:separator])\n next unless I18n::Translate.is_enhanced?(entry)\n %w(old t).each do |prop|\n next unless entry[prop]\n value = entry.delete(prop)\n prop = case(prop)\n when \"old\"\n \"old_default\"\n when \"t\"\n \"translation\"\n end\n entry[prop] = value\n end\n I18n::Translate.set(key, entry, data, @translate.options[:separator])\n end\n data\n end",
"def translate!( *args )\n super( *args )\n reset_positions_inside\n end",
"def translate(x, y = 0)\n current_transformation.translate(x, y)\n self[\"transform\"] = current_transformation.to_s\n end",
"def update\n @node.setTranslateX @node.getTranslateX + @vX\n @node.setTranslateY @node.getTranslateY + @vY\n end",
"def update_translations(locale, data)\n set_translations(locale, application.cache_translations(\n locale,\n key,\n data.is_a?(Hash) ? data['translations'] : data\n ))\n end",
"def translate(x, y = 0)\n transform[:translate] = [x, y]\n end",
"def update!(**args)\n @scale = args[:scale] if args.key?(:scale)\n @translate = args[:translate] if args.key?(:translate)\n end",
"def update\n @slide = Slide.find(params[:id])\n @slide.name = params[:slide][:name] unless params[:slide][:name].nil?\n @slide.position = params[:slide][:position] unless params[:slide][:position].nil?\n if @slide.update_attributes(params[:slide])\n flash[:notice] = \"Successfully updated slide.\"\n redirect_to @slide.presentation\n else\n render :action => 'edit'\n end\n end",
"def translate(p1, p2, p3, d)\r\n v = p3 - p2\r\n v.length = d\r\n trans=Geom::Transformation.translation(v)\r\n return p1.transform(trans)\r\n end",
"def translate(p1, p2, p3, d)\r\n v = p3 - p2\r\n v.length = d\r\n trans=Geom::Transformation.translation(v)\r\n return p1.transform(trans)\r\n end",
"def translate(p1, p2, p3, d)\r\n v = p3 - p2\r\n v.length = d\r\n trans=Geom::Transformation.translation(v)\r\n return p1.transform(trans)\r\n end",
"def translate(item)\n @progress.setMainStatusAndLogIt('Translating')\n text = get_original_text(item)\n return nil if text.empty?\n\n translated = ms_translate(text)\n super(item, translated) unless translated.nil? || translated.empty?\n end",
"def show\n @translate\n @uploaded_text = ''\n translation_map = []\n end",
"def set_next_slide\n if self.sequence-1>=1\n @slide=Slide.find_by_sequence_and_presentation_id(self.sequence-1,self.presentation_id)\n @slide.next_slide=self.id\n @slide.save\n end\n end",
"def translations; end",
"def translate\n self.translations.destroy\n\n if auto_translate\n google_translate\n bing_translate\n end\n end",
"def translate(settings); end",
"def set_slide\n @slide = @presentation.slides.friendly.find(params[:id]) \n end",
"def update\n respond_to do |format|\n if @tbl_slide.update(tbl_slide_params)\n format.html { redirect_to @tbl_slide, notice: 'Tbl slide was successfully updated.' }\n if session[:fromeditpage] == 1\n\n\n if params[:slidetrans_hid] == \"\"\n\n @slideinfo=TblSlide.find_by_SlideID(params[:id])\n @trans=@slideinfo.SlideTransition\n @transinfo=Transition.find_by_TransitionName(@trans)\n @transID=@transinfo.TransitionID\n params[:slidetrans_hid]=@transID\n\n end\n @transinfo=Transition.find_by_TransitionID(params[:slidetrans_hid])\n @transname=@transinfo.TransitionName\n\n querup='UPDATE tbl_slides SET \"SlideTransition\"='+\"'\"+\"#{@transname}\"+\"'\"+' Where \"SlideID\"='+\"#{params[:id]}\"+';'\n ActiveRecord::Base.connection.execute(querup);\n\n end\n format.json { render :show, status: :ok, location: @tbl_slide }\n else\n format.html { render :edit }\n format.json { render json: @tbl_slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if params[:dimension_translations]\n dimension_translations = params[:dimension_translations]\n parsed_dimension_translations = []\n dimension_translations.each do |number, trans|\n parsed_dimension_translations << {original_name: trans[:original_name].to_sym, translated_name: trans[:translated_name], data_type: trans[:data_type]} if trans[:original_name] != \"\"\n end\n\n @data_source.dimension_translations = parsed_dimension_translations\n end\n\n respond_to do |format|\n if @data_source.update(data_source_params)\n format.html { redirect_to @data_source, notice: 'Data source was successfully updated.' }\n format.json { render :show, status: :ok, location: @data_source }\n else\n format.html { render :edit }\n format.json { render json: @data_source.errors, status: :unprocessable_entity }\n end\n end\n end",
"def auto_translate\n return unless MuckContents.configuration.enable_auto_translations\n begin\n translate(false)\n rescue => ex\n #TODO figure out a way to bubble up the error\n puts ex\n debugger\n # Translations failed, but update the default language\n translation = translation_for(self.locale)\n translation.update_attributes!(:title => self.title, :body => self.body) unless translation.blank?\n end\n end",
"def translation=(translation)\n @translation.set(translation)\n @transform_dirty = true\n translation\n end",
"def update\n if @counter < TRANSITION_LENGHT\n @background.opacity = (@counter + 1) * 255 / TRANSITION_LENGHT\n elsif @counter < PHASE2\n base_x = (@counter - TRANSITION_LENGHT + 1) * @max_x * 3 / TEXT_MOVE_LENGHT\n @info_text.x = base_x + @info_ini_x\n @name_text.x = base_x + @name_ini_x\n elsif @counter.between?(PHASE3, PHASE_END)\n @info_text.opacity =\n @name_text.opacity = @background.opacity = (PHASE_END - @counter) * 255 / TRANSITION_LENGHT\n end\n @counter += 1\n end",
"def translate( dx ,dy)\n self.move( dx, dy)\n end",
"def store_original_as_translation\n unless self.original_text.nil?\n self.translations << self.original_text\n end\n end",
"def label_translation; end",
"def update\n @article = Article.find(params[:id])\n if @article.update(article_params)\n translate_art\n redirect_to @article\n else\n render 'edit'\n end\n end",
"def translate(details)\n self.translations = Hash[details.map { |k,v| [k.to_s, v.to_s] }].reverse_merge(self.translations)\n end",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def translate()\n\nend",
"def edit\n @data = SlidesHlp.getSlide(params[:id])\n if @data['slide_vi'] == nil\n @mode = 'I'\n else\n @slide = @data['slide_vi']\n @slide_ja = @data['slide_ja']\n @lang = @data['lang']\n @mode = 'U'\n end\n render 'admin/slides/slide'\n end",
"def translate(details)\n self.translations = Hash[details.map { |k, v| [k.to_s, v.to_s] }].reverse_merge(translations)\n end",
"def translate(point={})\n set RGhost::Cursor.translate(point)\n end",
"def translate(x, y, &rendering_code); end",
"def set_translation\n @translation = Translation.find(params[:id])\n end",
"def set_translation\n @translation = Translation.find(params[:id])\n end",
"def update_transition\r\n # If transition processing\r\n if $game_temp.transition_processing\r\n # Clear transition processing flag\r\n $game_temp.transition_processing = false\r\n # Execute transition\r\n if $game_temp.transition_name == ''\r\n Graphics.transition(20)\r\n else\r\n Graphics.transition(40, 'Graphics/Transitions/' +\r\n $game_temp.transition_name)\r\n end\r\n end\r\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n @inf = @slide.inform_id\n end",
"def update_transition\r\n # If transition is processing\r\n if $game_temp.transition_processing\r\n # Clear transition processing flag\r\n $game_temp.transition_processing = false\r\n # Execute transition\r\n if $game_temp.transition_name == \"\"\r\n Graphics.transition(20)\r\n else\r\n Graphics.transition(40, \"Graphics/Transitions/\" +\r\n $game_temp.transition_name)\r\n end\r\n end\r\n end",
"def apply_custom_transformation\n end",
"def set_page_translation\n @page_translation = PageTranslation.find(params[:id])\n end",
"def set_transform\n @transform = Transform.find(params[:id])\n end",
"def set_example_translation\n @example_translation = ExampleTranslation.find(params[:id])\n end",
"def reset_data\n ExpressTranslate.reset\n puts \"Reset successful!\"\n end",
"def init_translations; end",
"def update\n return false if !userCan :slide\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n if params[:projector_add] then\n params[:projector_add].each {|v|\n Projector.find(v).update_attributes(:slide_id => params[:id]);\n Message.Command(:id => \"projector-#{v}\", :cmd => \"load\", :slide => params[:id])\n }\n end\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to slides_url, notice: '幻灯片修改成功.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page_slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @page_slide.update_attributes(params[:page_slide])\n format.html { redirect_to page_slide_url(@page_slide.page, @page_slide), notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page_slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def translate(dx, dy)\n @xx += dx\n @yy += dy\n end",
"def translate( dx, dy)\n self.move(dx, dy)\n @groupList.each { |i| i.translate( dx, dy) }\n end",
"def bubble_update\n\t\tslide_asset.bubble_update\n\tend",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to presentation_slide_url(@presentation, @slide), notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n # update_move\n # update_tone_change\n update_rotate\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @page_translation.update(page_translation_params)\n format.html { redirect_to @page_translation, notice: 'Page translation was successfully updated.' }\n format.json { render :show, status: :ok, location: @page_translation }\n else\n format.html { render :edit }\n format.json { render json: @page_translation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to \"/slides\", notice: 'slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_data(data)\n @data_changed=true\n data ||= \"\"\n self.cur_pos=@last_pos=0\n clear_selection\n @data = data\n update_dimensions()\n refresh()\n end",
"def update\r\n\r\n data = params.except(:action, :controller, :options)\r\n options = params[:options]\r\n translations = GetPomo::PoFile.parse(File.read(\"#{Rails.root}/po/#{options[\"locale\"]}/#{APP_SID}.po\"))\r\n\r\n # Find translation\r\n\r\n @locale = translations.find { |t| t.comment == data[\"comment\"] }\r\n index = translations.find_index(@locale)\r\n\r\n # Edit translation\r\n\r\n @locale.msgid = data[\"msgid\"]\r\n @locale.msgstr = data[\"msgstr\"]\r\n @locale.comment = data[\"comment\"]\r\n if data.has_key?(\"fuzzy\") and data[\"fuzzy\"] == \"on\"\r\n @locale.comment += \", fuzzy\\n\" if @locale.fuzzy?.nil?\r\n else\r\n @locale.comment.slice! \", fuzzy\\n\" unless @locale.fuzzy?.nil?\r\n end\r\n\r\n # Replace translation\r\n\r\n translations[index] = @locale\r\n\r\n # Create delayed job to rewrite the PO file asynchronously\r\n\r\n Delayed::Job.enqueue WritePo.new(options[\"locale\"], GetPomo::PoFile.to_text(translations))\r\n render :json => @locale\r\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to @slide, notice: \"Slide was successfully updated.\" }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_slide\n @slide = Slide.nondraft.find(params[:id])\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to :back, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def process_data(lang, key, data)\n if data.is_a?(Hash)\n data.each do |subkey, subdata|\n subkey_fullname = key + (key == '' ? '' : '.') + subkey\n process_data(lang, subkey_fullname, subdata)\n end\n elsif data.is_a?(String)\n if $CURRENT_TRANSLATIONS[lang].key?(key)\n # Potential change to an existing translation\n this_current_translation = $CURRENT_TRANSLATIONS[lang][key]['target'].rstrip\n new_translation = data.rstrip\n if this_current_translation != new_translation\n # Translation has changed!\n id = $CURRENT_TRANSLATIONS[lang][key]['id']\n puts \"CHANGE TRANSLATION #{lang} KEY \\\"#{key}\\\"\"\n puts \" \\\"#{this_current_translation}\\\"\"\n puts \"=> id: #{id}\"\n puts \" \\\"#{new_translation}\\\"\"\n puts\n if !change_translation(id, new_translation)\n STDERR.puts \"Failed to update #{key} - halting\"\n exit 1\n end\n end\n else\n # Entirely NEW entry.\n new_translation = data\n if !$SOURCE.key?(key)\n STDERR.puts \"Source does not have key #{key}\"\n exit 1\n end\n source = $SOURCE[key]\n puts \"ADD TRANSLATION #{lang} KEY \\\"#{key}\\\":\"\n puts \" \\\"#{source}\\\"\"\n puts ' =>'\n puts \" \\\"#{new_translation}\\\"\"\n puts\n if !post_translation(key, lang, source, new_translation)\n STDERR.puts \"Failed to insert new translation for #{key} - halting\"\n exit 1\n end\n end\n elsif data.nil?\n # Ignore nil values\n else\n # Crash, something went wrong\n STDERR.puts \"Error: Bad class. Value '#{data}' has type #{data.class}\"\n exit 1\n end\nend",
"def replace_text old_text, new_text, slide_number = 0\n \n begin\n \n if @filename == ''\n raise 'filename not specified'\n end\n \n if old_text == ''\n raise 'old text not specified'\n end\n \n if new_text == ''\n raise 'new text not specified'\n end\n \n if(slide_number == 0)\n str_uri = $product_uri + '/slides/' + @filename + '/replaceText?oldValue=' + old_text + '&newValue=' + new_text + '&ignoreCase=true'\n else\n str_uri = $product_uri + '/slides/' + @filename + '/slides/' + slide_number.to_s + '/replaceText?oldValue=' + old_text + '&newValue=' + new_text + '&ignoreCase=true'\n end\n \n str_signed_uri = Aspose::Cloud::Common::Utils.sign(str_uri) \n response_stream = RestClient.post(str_signed_uri, '', {:accept=>'application/json'})\n \n valid_output = Aspose::Cloud::Common::Utils.validate_output(response_stream)\n \n if valid_output == ''\n folder = Aspose::Cloud::AsposeStorage::Folder.new\n output_stream = folder.get_file(@filename)\n output_path = $out_put_location + @filename \n Aspose::Cloud::Common::Utils.save_file(output_stream,output_path)\n return ''\n else\n return valid_output\n end \n \n rescue Exception=>e\n print e\n end\n \n end",
"def apply_transform!\n @location = @dy.transformPoint( @location )\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def update\n @slide.row_order_position = slide_params[:row_order_position]\n if @slide.save\n render nothing: true\n else\n render json: {files: [{\n error: @slide.errors.full_messages.join(\" \")\n }]}, status: 400\n end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to [:admin, @slide], notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def return_slide_and_data\n target_sentence = nil\n loop do\n target_word = @enrolment_manager.next_word\n return { service: 'EMPTY' } if target_word.nil?\n target_sentence = @next_sentence_retriever.retrieve(target_word)\n break if target_sentence.present?\n @enrolment_manager.assign_status(target_word, EXHAUSTED)\n end\n SlideConstructor.new(@enrolment_manager, target_sentence).construct\n end",
"def transformation=(transform)\n end",
"def copy_translation_attribute(deal, syndicated_deal, attr)\n original_locale = deal.class.locale\n deal.translated_locales.each do |locale|\n deal.class.locale = locale\n syndicated_deal.send(\"#{attr}=\", scrub_synchronization_attribute(deal,attr))\n end\n deal.class.locale = original_locale\n end",
"def translate_pos(given)\n Zif.add_positions(Zif.position_math(:mult, given, zoom_factor), pos)\n end",
"def translate_button(element)\n haml_tag :p, { source: element, class: 'translate btn', style: 'margin: 10px 0 10px 0'} do\n haml_tag :span, {class: 'translate_text'} do\n haml_concat t('kabupaten.translate')\n end\n haml_tag :span, {class: 'untranslate_text', style: 'display:none'} do\n haml_concat t('kabupaten.original_text')\n end\n haml_tag :span, {class: 'original_text', style: 'display:none'}\n haml_tag :span, {class: 'translated_text', style: 'display:none'}\n end\n end",
"def original\n @original ||= @container[:translation].original\n end",
"def uhook_update_widget\n widget = ::Widget.find(params[:id])\n if current_locale != widget.locale\n widget = widget.translate(current_locale, :copy_all => true)\n widget.locale = current_locale\n end\n params[:widget].each do |field, value|\n widget.send(\"#{field}=\", value)\n end\n widget.save\n widget\n end",
"def transformation\n end",
"def transforms; end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def translate(*args, **opts); end",
"def transform\n # Pass through\n @target.transform\n end",
"def update_foreign_keys_to_point_another_translation record\n record.without_current_locale do\n associated = record.send(name)\n associated.update_all({foreign_key => record.translations.first.id})\n end\n end",
"def update!(**args)\n @glossary_translations = args[:glossary_translations] if args.key?(:glossary_translations)\n @translations = args[:translations] if args.key?(:translations)\n end",
"def update\n @locale_entry.assign_attributes(update_params)\n\n @locale_entry.translated = true\n @locale_entry.translator = current_user\n\n @locale_entry.save\n respond_with @source_entry, @locale_entry, location: glossary_url\n end",
"def operate_switch_language(code)\n #callback(:before_switch_language)\n @translation_cache = {} if @translation_cache.nil?\n facet_names = self.class.globalize_facets\n @translation_cache[language_code] = @attributes.dup.delete_if {|key, value| !facet_names.include? key.to_sym}\n Locale.switch(code) do\n set_original_language\n if @translation_cache.include? code\n @attributes.update @translation_cache[code]\n elsif @original_language == Locale.base_language and !@new_record\n reload\n elsif !@new_record\n trs = ModelTranslation.find(:all, \n :conditions => [ \"table_name = ? AND item_id = ? AND language_id = ? AND \" +\n \"facet IN (#{[ '?' ] * facet_names.size * ', '})\", self.class.table_name,\n self.id, @original_language.id ] + facet_names.map {|facet| facet.to_s} )\n trs ||= []\n trs.each do |tr|\n attr = tr.text || base[tr.facet.to_s]\n write_attribute( tr.facet, attr )\n end\n end\n \n operate_switch_language_on_associations(code)\n \n #callback(:after_switch_language)\n end\n end",
"def update\n @pslide = Pslide.find(params[:id])\n\n respond_to do |format|\n if @pslide.update_attributes(params[:pslide])\n format.html { redirect_to @pslide, notice: 'Pslide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @pslide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_lesson_translation # rubocop:disable Metrics/AbcSize\n @course = Course.find_by(:sequential_id => params[:course_id])\n @subject = @course.subjects.find_by(:sequential_id => params[:subject_id])\n @lesson = @subject.lessons.find_by(:sequential_id => params[:lesson_id])\n @lesson_translation = @lesson.lesson_translations.find_by(\n :sequential_id => params[:id]\n )\n end",
"def setTransform(transform)\n # Pass through\n @target.transform = transform\n end",
"def update!(**args)\n @transformations = args[:transformations] if args.key?(:transformations)\n end",
"def update\n @translation = Translation.find(params[:id])\n @translation.update_attributes(params[:translation])\n respond_with @translation\n end"
] |
[
"0.600775",
"0.6000597",
"0.58729243",
"0.5831652",
"0.5821957",
"0.57016015",
"0.569445",
"0.5568196",
"0.5447744",
"0.5447744",
"0.54306793",
"0.5430647",
"0.5430561",
"0.54159015",
"0.5387675",
"0.53738725",
"0.536614",
"0.53024817",
"0.52914494",
"0.5286722",
"0.5283436",
"0.5249008",
"0.52400565",
"0.5236074",
"0.5232381",
"0.51981646",
"0.51604235",
"0.51561",
"0.5148327",
"0.5148327",
"0.5148327",
"0.5148327",
"0.5148327",
"0.5148327",
"0.5148327",
"0.5148327",
"0.51407284",
"0.5139937",
"0.51282537",
"0.51228493",
"0.51216525",
"0.51171005",
"0.50995076",
"0.50893545",
"0.50814325",
"0.5077278",
"0.506479",
"0.5059142",
"0.50533724",
"0.5049367",
"0.5040841",
"0.50404555",
"0.5033517",
"0.50332594",
"0.50326097",
"0.5022743",
"0.5021692",
"0.49991608",
"0.498928",
"0.4975542",
"0.4975542",
"0.4975542",
"0.4975542",
"0.4975542",
"0.49744883",
"0.4973152",
"0.49713778",
"0.49688184",
"0.496088",
"0.49597177",
"0.4958051",
"0.49514356",
"0.49511576",
"0.49431357",
"0.4937149",
"0.49336985",
"0.49301142",
"0.4918505",
"0.49144623",
"0.49089223",
"0.4893952",
"0.48886162",
"0.4878679",
"0.48780528",
"0.4872175",
"0.48688096",
"0.48675337",
"0.48612213",
"0.48600882",
"0.48556012",
"0.4852609",
"0.48409668",
"0.48390308",
"0.48341852",
"0.48328263",
"0.4829749",
"0.48288545",
"0.48242828",
"0.48184806",
"0.4813351"
] |
0.60674554
|
0
|
update show status of slide
|
def updateShowSlide
result = Hash.new
result['status'] = true
begin # try
result['status'] = Slide.where(id: params[:id])
.update_all('slides.show = NOT slides.show, updated_by = ' + $user_id.to_s + ', updated_at = \'' + Time.now.to_formatted_s(:db) + '\'')
rescue # catch
result['status'] = false
result['error'] = "#{$!}"
ensure # finally
render json: result
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def show; @showing = false; end",
"def show_slide\n @slide = @slideshow.slides[session[:slide_index]]\n session[:slide_index] += 1\n if @slide.nil?\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n end\n render partial: \"show_slides\"\n end",
"def show_slide\n @slideshow = session[:slideshow]\n session[:slide_index] += 1\n @slide = @slideshow.slides[session[:slide_index]]\n if @slide == nil\n session[:slide_index] = 0\n @slide = @slideshow.slides[session[:slide_index]]\n end\n render :partial => \"show_slide\"\n end",
"def show\n session[:slideshow] = @slideshow\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n end",
"def set_slide\n @slide = Slide.nondraft.find(params[:id])\n end",
"def show\n @contents = @slide.contents\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n @inf = @slide.inform_id\n end",
"def set_show(val)\n self.show = val\n self\n end",
"def show\n self.visible = true\n end",
"def update\n respond_to do |format|\n if UpdateSlide.execute(@slide, slide_params, current_user)\n @slide.take_screenshot\n @slide.create_activity(:update, owner: current_user, parameters: { name: @slide.menu_name })\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_show\n\tend",
"def update_show\n\tend",
"def set_slide\n @slide = @presentation.slides.friendly.find(params[:id]) \n end",
"def toggle_status\n self.published = !published\n self.save\n end",
"def visible=(state)\n return false if (state ? true : false) == self.visible?\n if state\n iws = [300, 300]\n @dialog = ::UI::WebDialog.new(@title, false, @title, iws.x, iws.y, 800, 600, false)\n # Callbacks\n @dialog.add_action_callback('init') { |dlg, params|\n unless @init_called\n @init_called = true\n ds = eval(params)\n #@border_size = [iws.x - ds.x, iws.y - ds.y]\n if RUBY_PLATFORM =~ /mswin|mingw/i && @handle\n ws = AMS::Window.get_size(@handle)\n cr = AMS::Window.get_client_rect(@handle)\n cs = [cr[2] - cr[0], cr[3] - cr[1]]\n @border_size = [ws.x - cs.x, ws.y - cs.y]\n else\n @border_size = [2, 24]\n end\n end\n @sliders.each { |name, data|\n generate_slider_html(name, false)\n }\n dlg.execute_script(\"update_size();\")\n }\n @dialog.add_action_callback('size_changed') { |dlg, params|\n @size = eval(params)\n update_placement\n }\n @dialog.add_action_callback('mouse_enter') { |dlg, params|\n @mouse_over = true\n }\n @dialog.add_action_callback('mouse_leave') { |dlg, params|\n @mouse_over = false\n AMS::Sketchup.activate if RUBY_PLATFORM =~ /mswin|mingw/i\n }\n @dialog.add_action_callback('update_note') { |dlg, params|\n next if RUBY_PLATFORM !~ /mswin|mingw/i\n cmd = \"\"\n if AMS::Sketchup.is_main_window_active?\n cmd << \"$('#note1').css('display', 'none');\"\n cmd << \"$('#note2').css('display', 'none');\"\n cmd << \"$('#note3').fadeIn(750);\"\n elsif AMS::Window.is_active?(@handle)\n cmd << \"$('#note1').css('display', 'none');\"\n cmd << \"$('#note3').css('display', 'none');\"\n cmd << \"$('#note2').fadeIn(750);\"\n else\n cmd << \"$('#note2').css('display', 'none');\"\n cmd << \"$('#note3').css('display', 'none');\"\n cmd << \"$('#note1').fadeIn(750);\"\n end\n dlg.execute_script(cmd)\n }\n # Set content\n dir = File.dirname(__FILE__)\n dir.force_encoding(\"UTF-8\") if RUBY_VERSION !~ /1.8/\n url = File.join(dir, 'html/control_panel.html')\n @dialog.set_file(url)\n # Show dialog\n RUBY_PLATFORM =~ /mswin|mingw/i ? @dialog.show : @dialog.show_modal\n # Assign the on_close callback. Important: This must be called after\n # showing dialog in order to work on Mac OS X.\n @dialog.set_on_close {\n if RUBY_PLATFORM =~ /mswin|mingw/i\n AMS::Sketchup.include_dialog(@handle)\n AMS::Sketchup.remove_observer(self)\n end\n @dialog.execute_script('uninit();')\n @dialog = nil\n @handle = nil\n @mouse_over = false\n @init_called = false\n }\n # Find dialog window handle\n @handle = RUBY_PLATFORM =~ /mswin|mingw/i ? AMS::Sketchup.find_window_by_caption(@title) : nil\n if @handle\n # Add observer\n AMS::Sketchup.add_observer(self)\n # Remove dialog caption and borders\n layered = AMS::System.get_windows_version < 6.0 ? 0 : 0x00080000\n style_ex = 0x00010000 | layered # WS_EX_CONTROLPARENT | WS_EX_LAYERED\n #style = 0x54000000 # WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS\n style = 0x94000000 # WS_POPUP | WS_VISIBLE | WS_CLIPSIBLINGS\n AMS::Window.lock_update(@handle)\n AMS::Window.set_long(@handle, -20, style_ex)\n AMS::Window.set_long(@handle, -16, style)\n AMS::Window.lock_update(nil)\n AMS::Window.set_pos(@handle, 0, 0, 0, 0, 0, 0x0267)\n AMS::Window.set_layered_attributes(@handle, 0, 200, 2)\n AMS::Sketchup.ignore_dialog(@handle)\n AMS::Sketchup.activate\n end\n else\n @dialog.close\n end\n true\n end",
"def on_display\n update!\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def show\n update_clicks\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def update_page_on_show(page)\n if wants_refresh?\n page.update_frame_for(object)\n else\n page.push_frame_for(object)\n end\n end",
"def set_showing\n @showing = Showing.find(params[:id])\n end",
"def set_showing\n @showing = Showing.find(params[:id])\n end",
"def set_showing\n @showing = Showing.find(params[:id])\n end",
"def update(status)\n @pivotal_story.update(current_state: status)\n end",
"def set_slide\n @slide = Slide.find(params[:id])\n end",
"def show\n redirect_to :admin_slider_images , notice: 'Slider image was not updated. Please try again'\n end",
"def show\n @visible = true\n self\n end",
"def set_slide\n @slide = Slide.where(id: params[:id]).accessible_by(current_ability).take\n end",
"def appear\n @inposition = false\n @loaded = true\n end",
"def knx_update(status)\n # Find widget for actual device\n @widget = self.class.find_by_id(self.id)\n # Update widget status\n if status.class == KNX4R::Status_of_Slider\n @widget.status = status.position.to_i\n else\n @widget.status = status\n end\n # Send the update to all running sessions\n unless ActionCable.server.logger.nil?\n ActionCable.server.broadcast 'widgets', {type: \"slider\", id: self.id, status: @widget.status}\n end\n end",
"def show\n update\n end",
"def show\n style[:hidden] = false\n update_visibility\n end",
"def auto_update_status \n if self.status == \"To Be Published\"\n self.status = \"Published\"\n end \n end",
"def appear\n refresh\n self.visible = true\n self.opacity = 255\n end",
"def show!\n visible(true)\n end",
"def show!\n visible(true)\n end",
"def changeShow\n @feedback = Feedback.find(params[:id])\n @feedback.show = !@feedback.show\n @feedback.save\n redirect_to feedbacks_path\n end",
"def play_action\n @status.playback_state = :playing\n update_status\n end",
"def set_slideshow\n @slideshow = Slideshow.find(params[:id])\n end",
"def set_slideshow\n @slideshow = Slideshow.find(params[:id])\n end",
"def published!\n self.update_attribute(:status, PUBLISHED)\n end",
"def index\n logger.info params.inspect\n if params[:toggle_activation]\n slide = Slide.where(:id => params[:toggle_activation]).first\n logger.info slide\n slide.toggle_visibility!\n slide.save\n end\n if params[:up]\n slide = Slide.where(:position => params[:up]).first\n if slide.position > 1\n other_slide = Slide.where(:position => slide.position-1).first\n other_slide.increment :position\n slide.decrement :position\n other_slide.save\n slide.save\n slide.reorder_positions!\n end\n end\n if params[:down]\n slide = Slide.where(:position => params[:down]).last\n logger.info \"found slide #{slide.inspect}\"\n if slide.position < Slide.where(:visible => true).count\n other_slide = Slide.where(:position => slide.position+1).first\n other_slide.decrement :position\n slide.increment :position\n other_slide.save\n slide.save\n slide.reorder_positions!\n end\n end\n\n @slides = Slide.find( :all, :order => \"visible DESC, position ASC\")\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @slides }\n end\n end",
"def change_status\n @is_published ? false : true\n end",
"def show_works_widget\n @show_works_widget = true\n end",
"def sdk_update_status(instance)\n if raw_power_state != instance.status\n update!(:raw_power_state => instance.status) if raw_power_state != instance.status\n $ibm_cloud_log.info(\"VM instance #{instance.id} state is #{raw_power_state}\")\n end\n end",
"def sdk_update_status(instance)\n if raw_power_state != instance.status\n update!(:raw_power_state => instance.status) if raw_power_state != instance.status\n $ibm_cloud_log.info(\"VM instance #{instance.id} state is #{raw_power_state}\")\n end\n end",
"def show_full\n @show_full=true\n end",
"def set_next_slide\n if self.sequence-1>=1\n @slide=Slide.find_by_sequence_and_presentation_id(self.sequence-1,self.presentation_id)\n @slide.next_slide=self.id\n @slide.save\n end\n end",
"def show\n published_check\n end",
"def show(show)\n dsl_data[:show] = show\n end",
"def show \n @videoshop = Videoshop.find(params[:id])\n id = @videoshop.id\n x = @videoshop.views\n vw = Videoshop.update(id, :views => x+1)\n vw.save\n end",
"def set_promo_slide\n @promo_slide = PromoSlide.find(params[:id])\n end",
"def refresh_live_status\n self.status.live?\n end",
"def show\n @questionnaire.update_attributes(status: :warn)\n end",
"def set_published_state; end",
"def show\n @slide = Slide.find(params[:id])\n @slide = @slide.version_at(Time.at(params[:version].to_i+1)) if params[:version]\n\n @menu_archiv_link = '<a id=\"drop1\" href=\"#\" role=\"button\" class=\"dropdown-toggle\" data-toggle=\"dropdown\">Version<b class=\"caret\"></b></a><ul class=\"dropdown-menu\" role=\"menu\" aria-labelledby=\"drop2\">'\n @slide.versions.each{|v|\n @menu_archiv_link += '<li><a href=\"'+url_for(:version => v.created_at.to_i )+'\" >'+v.created_at.to_s+'</a></li>'\n }\n @menu_archiv_link += '</ul>'\n @menu_archiv_link = @menu_archiv_link.html_safe\n\n @load_push = true\n @menu_edit_link = (\"<a href='\"+edit_slide_path(@slide)+\"'>Edit</a>\").html_safe if userCould :slide\n\n if userCould :projector then\n @menu_cmd_link = '<a id=\"drop1\" href=\"#\" role=\"button\" class=\"dropdown-toggle\" data-toggle=\"dropdown\">Beamer<b class=\"caret\"></b></a><ul class=\"dropdown-menu\" role=\"menu\" aria-labelledby=\"drop2\">'\n Projector.all.each{|p|\n @menu_cmd_link += '<li><a href=\"#\" onclick=\\'$.post(\"'+(url_for p)+'\", { \"command[cmd]\": \"load\", \"command[slide]\": \"'+@slide.id.to_s+'\", \"authenticity_token\" : \"'+form_authenticity_token+'\"} );\\'>'+p.name+'</a></li>' \n }\n @menu_cmd_link += '</ul>'\n @menu_cmd_link = @menu_cmd_link.html_safe\n end\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @slide }\n format.text { @broadcast=true; render :text => render_to_string('_show', :layout => false, :formats => \"html\") }\n end\n end",
"def swiffView(swiffView, didUpdateCurrentFrame:frame)\n if @movieView.playhead.frame.nil?\n @timelineSlider.setValue(1)\n else\n i = @movieView.playhead.frame.indexInMovie\n @timelineSlider.setValue(i.to_f)\n end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to [:admin, @slide], notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to slides_url, notice: '幻灯片修改成功.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to @slide, notice: \"Slide was successfully updated.\" }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { render :show, status: :ok, location: @slide }\n else\n format.html { render :edit }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_slideshow\n @slideshow = Slideshow.find_by_uid(params[:id].downcase)\n end",
"def set_show\n @show = Show.find(params[:id])\n end",
"def set_show\n @show = Show.find(params[:id])\n end",
"def set_show\n @show = Show.find(params[:id])\n end",
"def set_show\n @show = Show.find(params[:id])\n end",
"def set_show\n @show = Show.find(params[:id])\n end",
"def set_show\n @show = Show.find(params[:id])\n end",
"def set_show\n @show = Show.find(params[:id])\n end",
"def saveSlide\n if params[:mode] == 'I'\n update = SlidesHlp.saveSlide(params[:slide])\n else\n update = SlidesHlp.updateSlide(params[:slide])\n end\n render json: update\n end",
"def bubble_update\n\t\tslide_asset.bubble_update\n\tend",
"def show\n @auto_rotate = true\n @method = 'show'\n end",
"def set_presentation\n @presentation = Presentation.find(params[:id])\n end",
"def toggle\n if visible?\n hide\n\n else\n show\n\n end\n end",
"def update\n respond_to do |format|\n if @slide.update(slide_params)\n format.html { redirect_to presentation_slide_url(@presentation, @slide), notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @slider.update(slider_params)\n format.html { redirect_to action: :index, notice: 'Обновлено.' }\n format.json { render :index, status: :ok, location: @slider }\n else\n format.html { render :crop }\n format.json { render json: @slider.errors, status: :unprocessable_entity }\n end\n end\n end",
"def showing #same as attr_reader -> just lets you see value\n return @showing\n end",
"def set_show\n @show = Show.find(params[:show_id])\n end",
"def set_presentation\n @presentation = Presentation.find(1)\n end",
"def update?\n show?\n end",
"def update?\n show?\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to :back, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def toggle!\n self.featured = !self.featured\n save\n end",
"def show(opts={}, force=false)\n return false if scope.interval > Time.now - state.time_last_show and force == false\n\n update(opts)\n hook_exit\n\n state.time_last_show = Time.now\n state.closed = false\n scope.output.call(scope.template.pre)\n scope.output.call(render)\n scope.output.call(scope.template.post)\n true\n end",
"def update\n respond_to do |format|\n if @promo_slide.update(promo_slide_params)\n format.html { redirect_to @promo_slide, notice: 'Promo slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @promo_slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def toggle_status\n if @solution_specialization.toggle_status\n action = @solution_specialization.published? ? \"published\" : \"unpublished\"\n redirect_to solution_specializations_path, :notice => t(\"solution_specs.#{action}_successfully\")\n else\n redirect_to solution_specializations_path, :alert => t(\"solution_specs.cannot_unpublished\")\n end\n end",
"def resurrect\n show_data = Show.check_for_show_data(title)\n new_show_status = nil\n show_data.split(\"\\n\").each {|data| new_show_status = data.match(/@(.+)$/).captures.first if data[/^Status/] }\n\n return false if self.status == new_show_status\n\n self.update_inactive_data!\n end",
"def show\n @slideshow = Slideshow.find(params[:id])\n session[:slideshow] = @slideshow\n session[:slide_index] = 0\n @slide = @slideshow.slides[0]\n\n#respond_to do |format|\n# format.html # show.html.erb\n# format.xml { render :xml => @slideshow }\n# end\n end",
"def hidden_slides=(v)\n Axlsx.validate_int v\n @hidden_slides = v\n end",
"def show\n @carousel_slides = @carousel.carousel_slides\n end",
"def set_show_fps_counter(show:)\n {\n method: \"Overlay.setShowFPSCounter\",\n params: { show: show }.compact\n }\n end",
"def show\n @agenda = Agenda.find(params[:id])\n @slides= @agenda.slides\n @slide= @slides[0] if @slides.count == 1 and !params[:slide]\n @slide= Slide.find(params[:slide]) if params[:slide]\n @menu_edit_link = (\"<a href='\"+edit_agenda_path(@agenda)+\"'>Edit</a>\").html_safe if userCould :agendas\n\n if ((userCould :slide) or (userCould :projector)) and !@slide.nil? then\n @menu_cmd_link = '<a id=\"drop1\" href=\"#\" role=\"button\" class=\"dropdown-toggle\" data-toggle=\"dropdown\">Slide<b class=\"caret\"></b></a><ul class=\"dropdown-menu\" role=\"menu\" aria-labelledby=\"drop2\">'\n Projector.all.each{|p|\n @menu_cmd_link += '<li><a href=\"#\" onclick=\\'$.post(\"'+(url_for p)+'\", { \"command[cmd]\": \"load\", \"command[slide]\": \"'+@slide.id.to_s+'\", \"authenticity_token\" : \"'+form_authenticity_token+'\"} );\\'>Auf Beamer '+p.name+'</a></li>' \n }if userCould :projector\n @menu_cmd_link += '<li><a href=\"'+edit_slide_path(@slide)+'\">Bearebieten</a></li>' if userCould :slide\n @menu_cmd_link += '</ul>'\n @menu_cmd_link = @menu_cmd_link.html_safe\n end\n\n @load_push = true\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @agenda }\n end\n end",
"def update\n log = \"\\nCAMBIOS:\\n\"\n if @slide.slide_tag != slide_params[:slide_tag]\n log += \"\\n-ETIQUETA-\\nANTES:\" + @slide.slide_tag + \"\\n- DESPUÉS: -\\n\" + slide_params[:slide_tag]\n else\n log += \"\\n-ETIQUETA-\\nSIN CAMBIOS.\"\n end\n if @slide.description != slide_params[:description]\n log += \"\\n-DESCRIPCION-\\nANTES:\" + @slide.description + \"\\n- DESPUÉS: -\\n\" + slide_params[:description]\n else\n log += \"\\n-DESCRIPCION-\\nSIN CAMBIOS.\"\n end\n if @slide.stored != slide_params[:stored]\n log += \"\\n-GUARDADO-\\nANTES:\" + (@slide.stored == true ? 'Si' : 'No') + \"\\n- DESPUÉS: -\\n\" + (slide_params[:stored] == true ? 'Si' : 'No')\n else\n log += \"\\n-GUARDADO-\\nSIN CAMBIOS.\"\n end\n log += \"\\nFECHA: \" + Date.today.strftime('%d/%m/%Y') + \"\\nUSUARIO: \" + current_user.email.to_s + \"\\nEtiqueta: \" + slide_params[:slide_tag]\n\n if @slide.update(slide_params)\n @slide.objections.each do |objection|\n objection.closed = true\n objection.close_user_id = current_user.id\n objection.close_date = @slide.updated_at\n objection.description = objection.description + log\n objection.save\n end\n redirect_to inform_path(@inf), notice: 'La muestra ha sido exitosamente actualizada.'\n else\n render :edit\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n @slide.name = params[:slide][:name] unless params[:slide][:name].nil?\n @slide.position = params[:slide][:position] unless params[:slide][:position].nil?\n if @slide.update_attributes(params[:slide])\n flash[:notice] = \"Successfully updated slide.\"\n redirect_to @slide.presentation\n else\n render :action => 'edit'\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to \"/slides\", notice: 'slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @slide = Slide.find(params[:id])\n\n respond_to do |format|\n if @slide.update_attributes(params[:slide])\n format.html { redirect_to @slide, notice: 'Slide was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @slide.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
[
"0.6542944",
"0.64448625",
"0.6404435",
"0.6346779",
"0.62538993",
"0.60797113",
"0.60591894",
"0.60416937",
"0.59968007",
"0.59854925",
"0.5942338",
"0.5942338",
"0.59081703",
"0.5873936",
"0.5863659",
"0.58616453",
"0.5834114",
"0.5834114",
"0.5834114",
"0.5834114",
"0.5834114",
"0.58207285",
"0.57964134",
"0.57957596",
"0.5770031",
"0.5770031",
"0.5768876",
"0.57474774",
"0.5739908",
"0.5716356",
"0.5709563",
"0.56809616",
"0.5676772",
"0.5673454",
"0.56702954",
"0.5666634",
"0.56254494",
"0.5623937",
"0.5620757",
"0.5620757",
"0.56204623",
"0.56097656",
"0.56016034",
"0.56016034",
"0.5599889",
"0.55695295",
"0.5558407",
"0.5548133",
"0.55364877",
"0.55364877",
"0.5535227",
"0.55292565",
"0.55284953",
"0.5522689",
"0.5522684",
"0.5522576",
"0.55184585",
"0.55168307",
"0.5513175",
"0.550784",
"0.54958206",
"0.549278",
"0.5491372",
"0.54913133",
"0.5486873",
"0.54726994",
"0.5469934",
"0.5469934",
"0.5469934",
"0.5469934",
"0.5469934",
"0.5469934",
"0.5469934",
"0.5466361",
"0.5444687",
"0.54407716",
"0.54402435",
"0.543199",
"0.54259557",
"0.5421767",
"0.54118156",
"0.54096985",
"0.5408944",
"0.540643",
"0.540643",
"0.5404059",
"0.5397862",
"0.53973556",
"0.53864",
"0.53837335",
"0.53738046",
"0.5369601",
"0.5364404",
"0.53633046",
"0.53547704",
"0.5354533",
"0.53510576",
"0.5350989",
"0.53316814",
"0.5321998"
] |
0.7222382
|
0
|
TODO: this method is too long split it up by refactoring
|
def run(options, argv)
pooled_reads_filename = 'pooled_sampled_reads.fasta' #TODO: remove this constant into a tempfile or something.
if options[:already_patterned_reads] #If skipping read extraction
pooled_reads_filename = options[:already_patterned_reads]
else
# Parse pattern from cmdline
desired_pattern = KmerAbundancePattern.new
desired_pattern.parse_from_human(options[:pattern])
if options[:reads_files].length != desired_pattern.length
raise "Number of entries in the pattern #{desired_pattern.length} and number of reads files #{options[:reads].length} not equivalent!"
end
# Collect the kmers that will be used to find trusted reads i.e.
# Go through each line of the kmer abundance file, looking for kmers that suit the pattern
input_file = File.open options[:kmer_multiple_abundance_file]
csv = CSV.new(input_file, :col_sep => ' ')
whitelist_kmers = []
blacklist_kmers = []
csv.each do |row|
max_i = row.length - 2 if max_i.nil?
kmer = row[0]
counts = row[1...row.length].collect{|s| s.to_i}
this_pattern = []
counts.each_with_index do |count, i|
if count > options[:upper_threshold]
this_pattern[i] = true
elsif count < options[:lower_threshold]
this_pattern[i] = false
else
# coverage was in no man's land between thresholds.
# Ignore this kmer as noise.
this_pattern[i] = '-'
end
end
#log.debug "Found pattern #{this_pattern} from kmer #{kmer}, which has abundances #{counts}" if log.debug?
if desired_pattern.consistent_with? this_pattern
whitelist_kmers.push row[0]
else
# kmer is not present when it should be
blacklist_kmers.push row[0]
end
end
log.info "After parsing the kmer multiple abundance file, found #{whitelist_kmers.length} kmers that matched the pattern, and #{blacklist_kmers.length} that didn't"
unless whitelist_kmers.length > 0
log.error "No kmers found that satisfy the given pattern, exiting.."
exit 1
end
#outdir = options[:output_directory]
#Dir.mkdir outdir unless Dir.exist?(outdir)
# grep the pattern out from the raw reads, subsampling so as to not overwhelm the assembler
#Tempfile.open('whitelist') do |white|
File.open 'whitelist', 'w' do |white| #TODO: remove 'whitelist' file as a constant
white.puts whitelist_kmers.join("\n")
white.close
#Tempfile.open('blacklist') do |black|
File.open('black','w') do |black|
black.puts blacklist_kmers.join("\n")
black.close
threadpool = []
sampled_read_files = []
log.info "Extracting reads that contain suitable kmers"
options[:reads_files].each_with_index do |file, i|
next unless desired_pattern[i] #Don't extract reads from reads where those reads should not have been amplified
sampled = File.basename(file)+'.sampled_reads.fasta'
sampled_read_files.push sampled
grep_path = "#{ ENV['HOME'] }/git/priner/bin/read_selection_by_kmer " #TODO: this won't work on other people's systems.
if options[:min_leftover_length]
grep_path += "--min-leftover-length #{options[:min_leftover_length]} "
end
thr = Thread.new do
grep_cmd = "#{grep_path} --whitelist #{white.path} --blacklist #{black.path} --reads #{file} --kmer-coverage-target #{options[:kmer_coverage_target]} > #{sampled}"
log.debug "Running cmd: #{grep_cmd}"
status, stdout, stderr = systemu grep_cmd
log.debug stderr
raise unless status.exitstatus == 0
log.debug "Finished extracting reads from #{file}"
end
threadpool.push thr
end
threadpool.each do |thread| thread.join; end #wait until everything is finito
log.info "Finished extracting reads for sampling. Now pooling sampled reads"
pool_cmd = "cat #{sampled_read_files.join ' '} >#{pooled_reads_filename}"
log.debug "Running cmd: #{pool_cmd}"
status, stdout, stderr = systemu pool_cmd
raise stderr if stderr != ''
raise unless status.exitstatus == 0
end
end
end
log.info "Extracting dummy reads from the ends of contigs to use as anchors"
start_contig = options[:start_contig]
end_contig = options[:end_contig]
if [start_contig.length, end_contig.length].min < 2*options[:contig_end_length]
log.warn "Choice of initial/terminal nodes to perform graph search with may not be optimal due to the small contig size"
end
if [start_contig.length, end_contig.length].min < options[:contig_end_length]
log.error "At least one contig too small to proceed with current code base, need to fix the code to allow such a small contig"
exit 1
end
probe_sequences = [
start_contig[start_contig.length-options[:contig_end_length]...start_contig.length],
Bio::Sequence::NA.new(end_contig[0...options[:contig_end_length]]).reverse_complement.to_s
]
read_input = Bio::FinishM::ReadInput.new
read_input.fasta_singles = [pooled_reads_filename]
finishm_graph = Bio::FinishM::GraphGenerator.new.generate_graph(probe_sequences, read_input, options)
graph = finishm_graph.graph
start_node = finishm_graph.probe_nodes[0]
start_node_forward = finishm_graph.probe_node_directions[0]
end_node = finishm_graph.probe_nodes[1]
end_node_forward = finishm_graph.probe_node_directions[1]
log.info "Node(s) found that are suitable as initial and terminal nodes in the graph search, respectively: #{start_node.node_id} and #{end_node.node_id}"
log.info "Removing nodes unconnected to either the start or the end from the graph.."
original_num_nodes = graph.nodes.length
original_num_arcs = graph.arcs.length
filter = Bio::AssemblyGraphAlgorithms::ConnectivityBasedGraphFilter.new
filter.remove_unconnected_nodes(graph, [start_node, end_node])
log.info "Removed #{original_num_nodes-graph.nodes.length} nodes and #{original_num_arcs-graph.arcs.length} arcs"
if options[:output_graph_png] or options[:output_graph_svg] or options[:output_graph_dot]
viser = Bio::Assembly::ABVisualiser.new
log.info "Preparing GraphViz object for output"
gv = viser.graphviz(graph, {:start_node_id => start_node.node_id, :end_node_id => end_node.node_id})
if options[:output_graph_png]
log.info "Converting assembly to a graphviz PNG #{options[:output_graph_png] }"
gv.output :png => options[:output_graph_png], :use => :neato
end
if options[:output_graph_svg]
log.info "Converting assembly to a graphviz SVG #{options[:output_graph_svg] }"
gv.output :svg => options[:output_graph_svg], :use => :neato
end
if options[:output_graph_dot]
log.info "Converting assembly to a graphviz DOT #{options[:output_graph_dot] }"
gv.output :dot => options[:output_graph_dot]
end
end
log.info "Searching for trails between the initial and terminal nodes, within the assembly graph"
cartographer = Bio::AssemblyGraphAlgorithms::AcyclicConnectionFinder.new
#raise "Untested connection finder below"
#trails = cartographer.find_all_trails_between_nodes(graph, start_node, end_node, options[:graph_search_leash_length], start_node_forward)
trails = cartographer.find_trails_between_nodes(graph, start_node, end_node, options[:graph_search_leash_length], start_node_forward)
log.info "Found #{trails.length} trail(s) between the initial and terminal nodes"
# log.info "Reading kmer abundances from #{options[:kmer_multiple_abundance_file]}.."
# kmer_hash = Bio::KmerMultipleAbundanceHash.parse_from_file options[:kmer_multiple_abundance_file]
# log.info "Finished reading the kmer abundances"
# if options[:trail_kmer_coverage_file]
# log.info "Writing out kmer coverages to #{options[:trail_kmer_coverage_file]}.."
# writer = Bio::AssemblyGraphAlgorithms::KmerCoverageWriter.new
# io = File.open(options[:trail_kmer_coverage_file],'w')
# writer.write(io, trails, kmer_hash)
# log.info "Finished writing"
# end
# log.info "Filtering trail(s) based on kmer coverage, requiring each kmer in the path to have a minimum of #{options[:kmer_path_filter_min_coverage]} coverage in patterned reads, except for the #{options[:kmer_path_end_exclusion_length]}bp at the ends"
# kmer_path_filter = Bio::AssemblyGraphAlgorithms::KmerCoverageBasedPathFilter.new
# thresholds = desired_pattern.collect{|c| c == true ? 1 : 0}
# log.info "Using thresholds for filtering: #{thresholds}"
# trails = kmer_path_filter.filter(trails, kmer_hash, thresholds, :exclude_ending_length => options[:kmer_path_end_exclusion_length])
# log.info "After filtering remained #{trails.length} trails"
printer = Bio::AssemblyGraphAlgorithms::ContigPrinter.new
trails.each_with_index do |trail, i|
log.debug "Before attachment to the contig, sequence of the trail was #{trail.sequence}" if log.debug?
acon = Bio::AssemblyGraphAlgorithms::ContigPrinter::AnchoredConnection.new
acon.start_probe_read_id = 1
acon.end_probe_read_id = 2
acon.start_probe_node = start_node
acon.end_probe_node = end_node
acon.start_probe_contig_offset = options[:contig_end_length]
acon.end_probe_contig_offset = options[:contig_end_length]
acon.paths = [trail]
log.debug "AnchoredConnection object to print for this trail: #{acon.inspect}" if log.debug?
puts ">trail#{i+1}"
puts printer.one_connection_between_two_contigs(
finishm_graph.graph,
probe_sequences[0],
acon,
probe_sequences[1])
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def private; end",
"def probers; end",
"def schubert; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def specie; end",
"def offences_by; end",
"def formation; end",
"def identify; end",
"def anchored; end",
"def terpene; end",
"def suivre; end",
"def berlioz; end",
"def stderrs; end",
"def rest_positionals; end",
"def parts; end",
"def parts; end",
"def parts; end",
"def intensifier; end",
"def implementation; end",
"def implementation; end",
"def verdi; end",
"def operations; end",
"def operations; end",
"def transformations; end",
"def required_positionals; end",
"def common\n \n end",
"def next() end",
"def next() end",
"def custom; end",
"def custom; end",
"def original_result; end",
"def trd; end",
"def refutal()\n end",
"def transform; end",
"def sitemaps; end",
"def user_os_complex\r\n end",
"def weber; end",
"def villian; end",
"def loc; end",
"def loc; end",
"def loc; end",
"def parslet; end",
"def parslet; end",
"def parslet; end",
"def parslet; end",
"def first; end",
"def first; end",
"def wrapper; end",
"def celebration; end",
"def rassoc(p0) end",
"def transforms; end",
"def reflector; end",
"def reflector; end",
"def from; end",
"def from; end",
"def from; end",
"def from; end",
"def offences_by=(_arg0); end",
"def internal; end",
"def starting_position; end",
"def deco_pos; end",
"def pos() end",
"def pos() end",
"def pos() end",
"def pos() end",
"def ignores; end",
"def escaper; end",
"def same; end",
"def malts; end",
"def schumann; end",
"def first_offset; end",
"def first_offset; end",
"def isolated; end",
"def isolated; end",
"def all_by_magic(io); end",
"def expanded; end",
"def returns; end",
"def original; end",
"def internship_passed; end",
"def bs; end",
"def pos; end",
"def pos; end",
"def pos; end",
"def pos; end",
"def pos; end",
"def pos; end",
"def processor; end",
"def apply\n\t\t\n\tend",
"def apply\n\t\t\n\tend",
"def fallbacks; end",
"def fallbacks; end",
"def ismn; end",
"def ext; end",
"def ext; end",
"def position; end",
"def position; end",
"def position; end",
"def position; end",
"def position; end"
] |
[
"0.67651063",
"0.5921294",
"0.5678794",
"0.56768227",
"0.56768227",
"0.56768227",
"0.56768227",
"0.55266863",
"0.5503148",
"0.5407889",
"0.5389143",
"0.53412527",
"0.5271127",
"0.52139384",
"0.5182962",
"0.51418954",
"0.5125917",
"0.5125917",
"0.5125917",
"0.51191753",
"0.5115373",
"0.5115373",
"0.50830954",
"0.5072744",
"0.5072744",
"0.5069396",
"0.50594795",
"0.5056845",
"0.5052647",
"0.5052647",
"0.5042437",
"0.5042437",
"0.50261784",
"0.50212365",
"0.49919873",
"0.49828506",
"0.49748585",
"0.49418378",
"0.4938263",
"0.49248812",
"0.49163678",
"0.49163678",
"0.49163678",
"0.49109218",
"0.49109218",
"0.49109218",
"0.49109218",
"0.4904668",
"0.4904668",
"0.4894455",
"0.48892882",
"0.4886388",
"0.48858434",
"0.4884785",
"0.4884785",
"0.48777846",
"0.48777846",
"0.48777846",
"0.48777846",
"0.48755804",
"0.4869194",
"0.48648998",
"0.48563442",
"0.4850523",
"0.4850523",
"0.4850523",
"0.4850523",
"0.4850155",
"0.48467037",
"0.48351246",
"0.482021",
"0.48157966",
"0.47999004",
"0.47999004",
"0.4798463",
"0.4798463",
"0.47978365",
"0.47877982",
"0.4787567",
"0.478484",
"0.47760373",
"0.47682652",
"0.47663915",
"0.47663915",
"0.47663915",
"0.47663915",
"0.47663915",
"0.47663915",
"0.4762766",
"0.4760277",
"0.4760277",
"0.47540537",
"0.47540537",
"0.47426298",
"0.4738321",
"0.4738321",
"0.47361583",
"0.47361583",
"0.47361583",
"0.47361583",
"0.47361583"
] |
0.0
|
-1
|
+nil+ is blank: nil.blank? => true
|
def blank?
true
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def blank?\n @value == nil\n end",
"def blank?\r\n nil? || (respond_to?(:empty?) && empty?)\r\n end",
"def blank?\n nil? || (respond_to?(:empty?) && empty?)\n end",
"def blank?\n nil? || (respond_to?(:empty?) && empty?)\n end",
"def blank?\n nil? || (respond_to?(:empty?) && empty?)\n end",
"def _blank?(value)\n value.nil? || value == ''\n end",
"def blank?\n self.nil? || self.empty?\n end",
"def blank?\n true\n end",
"def blank?\n empty?\n end",
"def blank?\n true\n end",
"def blank?\n false\n end",
"def blank?\n false\n end",
"def blank?\n empty?\n end",
"def blank?\n value.blank?\n end",
"def blank?(value)\n value.nil? == false && value.empty? == false\n end",
"def blank?(object)\n object.to_s.sub(/\\s+/, '') == ''\n end",
"def blank?(value)\n value.nil? || value.to_s.empty?\n end",
"def blank?\n false\n end",
"def blank?\n false\n end",
"def blank?\n false\n end",
"def blank?\n false\n end",
"def blank?\r\n empty? || BLANK_STRING_REGEXP.match(self)\r\n end",
"def blank?\n length == 0\n end",
"def blank?(val)\n val.respond_to?(:empty?) ? val.empty? : !val\n end",
"def blank?( object )\n return object.nil? || object.empty?\n end",
"def blank?\n BLANK_RE === self\n end",
"def blank?\n respond_to?(:empty?) ? !!empty? : !self\n end",
"def blank?\n respond_to?(:empty?) ? empty? : !self\n end",
"def is_blank?(var)\n var.nil? or (var.is_a?(String) and var.strip.empty?)\n end",
"def blank?(obj)\n obj.respond_to?(:empty?) ? obj.empty? : !obj\n end",
"def blank?\n to_s.blank?\n end",
"def blank?\n self.strip.length === 0\n end",
"def blank?(value)\n value.nil? || BLANK_REGEX === value\n end",
"def blank?\n attributes.values.all?(&:blank?)\n end",
"def blank?\n attributes.values.all?(&:blank?)\n end",
"def blank?\n attributes.values.all?(&:blank?)\n end",
"def blank?\n attributes.values.all?(&:blank?)\n end",
"def is_blank? item\n\titem.nil? || item.gsub(/\\s+/, \"\").empty?\nend",
"def blank?\n attributes.values.all?(&:blank?)\n end",
"def isBlankOrNull(param = null)\r\n\t \r\n\t \tif param.nil? || param===\"NA\" || param.empty?\r\n\t \t return true\r\n\t \telse\r\n\t \t return false\r\n\t \tend\r\n\t \t\r\n\t end",
"def blank?\n self.strip.empty?\n end",
"def blank?(str)\n str.nil? || str.to_s.strip == ''\nend",
"def blank?(value)\n return value.blank? if value.respond_to?(:blank?)\n\n value.respond_to?(:empty?) ? !!value.empty? : !value\n end",
"def truthy?\n if respond_to? :blank?\n not blank?\n else\n not nil?\n end\n end",
"def truthy?\n if respond_to? :blank?\n not blank?\n else\n not nil?\n end\n end",
"def blank?\n self.strip.size == 0\n end",
"def blank?(a)\n return true unless a\n BLANK_STRING_RE === a\n end",
"def blank?(str)\n str.nil? or (str.is_a? String and str.strip.empty?)\n end",
"def blank?\n strip.empty?\n end",
"def blank?\n self !~ /[^[:space:]]/\n end",
"def empty_nil_blank?(str, raize=false)\n result = (str !~ /[^[:space:]]/ || str.nil? || str.empty?)\n raise ShellTastic::CommandException.new(\"Command is emtpy or nil\") if result and raize\n result\n end",
"def blank?\n # The regexp that matches blank strings is expensive. For the case of empty\n # strings we can speed up this method (~3.5x) with an empty? call. The\n # penalty for the rest of strings is marginal.\n empty? || BLANK_RE === self\n end",
"def blank?(object) \n\tif object.instance_of?(Array) || object.instance_of?(Hash)\n\t\treturn object.nil? || object.length == 0\n\telse\n\t\treturn object.nil? || object.strip == ''\n\tend\nend",
"def is_blank?(o)\n if o.is_a?(RubyMotionQuery::RMQ)\n RubyMotionQuery::RMQ.is_blank?(o.to_a)\n else\n o.respond_to?(:empty?) ? o.empty? : !o\n end\n end",
"def blank_object?(obj)\n return obj.blank? if obj.respond_to?(:blank?)\n case obj\n when NilClass, FalseClass\n true\n when Numeric, TrueClass\n false\n when String\n obj.strip.empty?\n else\n obj.respond_to?(:empty?) ? obj.empty? : false\n end\n end",
"def present?\n not blank?\n end",
"def blank?\n # The regexp that matches blank strings is expensive. For the case of empty\n # strings we can speed up this method (~3.5x) with an empty? call. The\n # penalty for the rest of strings is marginal.\n empty? || BLANK_RE.match?(self)\n end",
"def blank?\n self.value.blank? || self.deleted?\n end",
"def blank?\n @values.blank?\n end",
"def nil?\n\t\t\tempty?\n\t\tend",
"def blank?\n strip.size == 0\n end",
"def blank?(param)\n param.nil? || param.empty?\n end",
"def blank?( string )\n string.respond_to?(:empty?) ? !!string.empty? : !string\n end",
"def blank?\n return true if @target.nil?\n @target.respond_to?(:empty?) ? @target.empty? : !@target\n end",
"def skip_blanks?() @skip_blanks end",
"def blank?\n if content.respond_to?(:empty?)\n content.empty?\n else\n content.nil?\n end\n end",
"def empty?\n name.blank?\n end",
"def nil_or_empty?(value)\n value.nil? || value.empty? ? true : false\n end",
"def empty?\r\n return @value == nil\r\n end",
"def nil_or_empty_string?(obj)\n obj.nil? || obj.empty?\n end",
"def object_blank?(obj)\n obj.respond_to?(:empty?) ? !!obj.empty? : !obj\n end",
"def value_empty?\n if value === nil or value === \"\"\n return true\n end\n return false\n end",
"def anything_blank?\n max_payment.blank? || min_payment.blank? || deposit.blank? || term.blank?\n end",
"def blank?\n [:city, :zip, :address_1, :address_2].all? do |attr|\n self.send(attr).blank?\n end\n end",
"def null?\n if( @length == 0 )\n return true\n else\n return false\n end\n end",
"def is_blank_space?\n get_type == :empty\n end",
"def is_empty?\n end",
"def nil_or_empty?(obj)\n obj.nil? || (obj.respond_to?(:empty?) && obj.empty?)\n end",
"def blank?\n @address_line1.blank? && @town.blank? && @postcode.blank?\n end",
"def empty?\n @val==nil\n end",
"def empty?(input)\n input == \"\" ? true : false\n end",
"def nil_or_empty?(value)\n return true if value.nil? || (value.respond_to?(:empty?) && value.empty?)\n\n false\nend",
"def blank?\n if title.present? and title != Survey::DEFAULT_TITLE\n return false\n end\n\n [:description, :instructions].each do |attr|\n return false if self.send(attr).present?\n end\n\n questions.each do |question|\n return false unless question.blank?\n end\n\n true\n end",
"def check_blank_value(key, val)\n # if we explicitly want nil attributes\n return true if self.options[:include_nil_attributes]\n # or if the attribute has changed to nil\n return true if self.record.changes[key].present?\n # make sure our value isn't blank\n return !val.nil?\n end",
"def IS_NIL(value)\n value.first == nil\n end",
"def non_empty?(obj)\n !(obj.nil? || obj.empty?)\n end",
"def null?\n true\n end",
"def nil?\n none?\n end",
"def blank?\n words.empty?\n end",
"def empty?() end",
"def empty?() end",
"def empty?() end",
"def empty?\n city.blank? && user.blank? && name.blank? && from_date.blank? && to_date.blank?\n end",
"def empty?\n none? { true }\n end",
"def isEmptyOrNull(value)\n if value == nil || value.eql?(\"\")\n return true\n else\n return false\n end\n end",
"def check_nil_empty(object)\n return false if object.nil? || object.empty?\n true\n end",
"def blank_param?(data)\n data.blank? || data.try(:values).try(:all?, &:blank?)\n end",
"def present?\n !blank?\n end"
] |
[
"0.8476583",
"0.8458991",
"0.83773017",
"0.8376911",
"0.8376911",
"0.83311534",
"0.83047694",
"0.8300094",
"0.82690495",
"0.8189922",
"0.81458604",
"0.81458604",
"0.81374216",
"0.80880964",
"0.8047782",
"0.80329067",
"0.8026663",
"0.80087924",
"0.7996571",
"0.7996571",
"0.7996571",
"0.798126",
"0.79779375",
"0.7913832",
"0.7912632",
"0.78989136",
"0.78583133",
"0.77790916",
"0.7746661",
"0.7702735",
"0.77011275",
"0.7696409",
"0.76726604",
"0.7650383",
"0.7650383",
"0.7650383",
"0.7650383",
"0.7630494",
"0.76116055",
"0.7558393",
"0.75326097",
"0.75155926",
"0.74924755",
"0.7489831",
"0.7489831",
"0.74741167",
"0.7473488",
"0.7472975",
"0.74656594",
"0.7447798",
"0.7446534",
"0.7433651",
"0.7430551",
"0.7425072",
"0.7418399",
"0.74182975",
"0.7396868",
"0.7381113",
"0.7375594",
"0.7353487",
"0.73357433",
"0.7331843",
"0.7292649",
"0.72638535",
"0.72550803",
"0.71892977",
"0.71602196",
"0.7143981",
"0.7141839",
"0.7121306",
"0.7109887",
"0.70996624",
"0.7084664",
"0.7070789",
"0.70442265",
"0.70363116",
"0.7033097",
"0.70295453",
"0.7025454",
"0.69962746",
"0.6920897",
"0.69169974",
"0.6904276",
"0.6902271",
"0.6884633",
"0.6866047",
"0.6865351",
"0.6865187",
"0.6849418",
"0.68429685",
"0.68429685",
"0.68429685",
"0.681623",
"0.6800763",
"0.6798756",
"0.67968833",
"0.67933524",
"0.6790886"
] |
0.8129024
|
13
|
Recursively call to_a on all connected Nodes and return an Array with their data. Time Complexity: O(n) Space Complexity: O(n)
|
def to_a
if next_node
[data].concat(next_node.to_a)
else
[data]
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def to_a\n ret = [self]\n if self.kids\n self.kids.each do |kid|\n kid.to_a.each {|node|\n ret.push node\n }\n end\n end\n ret\n end",
"def to_a\n result = []\n fill_result = proc { |node_data| result << node_data }\n in_order_run_callable(@root, fill_result)\n result\n end",
"def to_a\n nodes.map(&:at)\n end",
"def to_a\n @nodes\n end",
"def cache_nodes_to_array\n arr = []\n node = @rear_node\n begin\n arr << node.value\n node = node.parent\n end while !node.nil?\n return arr\n end",
"def to_a\n collect { |node| node.data }\n end",
"def all_nodes\n nodes = []\n visit_nodes do |node|\n nodes.push node\n end\n nodes\n end",
"def build_array(node)\r\n return [] if node.nil?\r\n results = []\r\n results.concat build_array(node.left)\r\n results << node.payload\r\n results.concat build_array(node.right)\r\n results\r\nend",
"def nodes\n @nodes ||= each_node.to_a\n end",
"def traversal\n list_array = []\n curr_node = @head\n while curr_node do\n list_array << curr_node\n curr_node = curr_node.next\n end\n\n list_array\n end",
"def tree_to_array(node)\n h = height(node)\n tree_arr = []\n (1..h).each do |n|\n tree_arr << node_at_a_level(node, n)\n end\n tree_arr\nend",
"def all_children\n reload\n nodes = []\n queue = children.to_a\n until queue.empty?\n node = queue.pop\n nodes.push(node)\n queue += node.children.to_a\n queue.flatten!\n end\n nodes\n end",
"def to_a\n _evaluated_nodes\n end",
"def dfs_helper(start_node)\n\n ret_list = [start_node.value]\n # Your code here\n start_node.visited = true\n start_node.edges.each do |edge|\n unless edge.node_to.visited\n ret_list += dfs_helper(edge.node_to)\n end\n end\n return ret_list\n end",
"def create_graph(arr)\n nodes = []\n (0...arr.size).each do |i|\n node = Node.new(i)\n nodes.push(node)\n end\n nodes.each_with_index do |node,i|\n arr[i].each {|val| node.connections.push(nodes[val])} \n end\n nodes\nend",
"def create_graph(arr)\n nodes = []\n (0...arr.size).each do |i|\n node = Node.new(i)\n nodes.push(node)\n end\n nodes.each_with_index do |node,i|\n arr[i].each {|val| node.connections.push(nodes[val])} \n end\n nodes\nend",
"def nodes\n nodes_by_id.values\n end",
"def all_nodes\n [self] + descendants\n end",
"def get_adjacent_nodes(node) #[[6,1]]\n\tadj = []\n\tnode = [node]\n\tnode.each do |node|\n\t\tx, y = node[0], node[1]\n\t\tadj = [[(x+1),y], [(x-1), y], [x, (y+1)], [x, (y-1)]]\n\tend\n\tadj\nend",
"def get_all_vals(node, arr)\n # add the value of the node to the array\n arr << node.val\n \n # using a ternary operator, check if there is another node in the list\n # if so, recursively run the function again\n # if not, return the array\n return node.next ? get_all_vals(node.next, arr) : arr\n end",
"def flat_edgelist\n ni = Hash.new\n @nodes.each_with_index { |n,i| ni[n]=i+1 }\n sa = []\n da = []\n @links.each_value do |l| \n sa << ni[l.src]\n da << ni[l.dest]\n end\n sa + da\n end",
"def get_adjacency_list\n max_index = find_max_index\n adjacency_list = [nil] * max_index\n @edges.each do |edg|\n from_value = edg.node_from.value\n to_value = edg.node_to.value\n if adjacency_list[from_value]\n adjacency_list[from_value] << [to_value, edg.value]\n else\n adjacency_list[from_value] = [[to_value, edg.value]]\n end\n end\n adjacency_list\n end",
"def _recursively_flatten_to!(array, out)\n array.each do |o|\n if NodeList === o\n _recursively_flatten_to!(o.nodes, out)\n elsif o.respond_to?(:to_ary)\n ary = Array === o ? o : o.to_ary\n _recursively_flatten_to!(ary, out)\n else\n out << o\n end\n end\n end",
"def to_a\n a = []\n each {|subc| a << subc}\n a\n end",
"def node_to_array(node)\n # Is this too clever?\n # { \"01\" => \"bar\", \"00\" => \"foo\", \"02\" => \"baz\" } # node_to_hash\n # [ [\"01\", \"bar\"], [\"00\", \"foo\"], [\"02\", \"baz\"] ] # to_a\n # [ [\"00\", \"foo\"], [\"01\", \"bar\"], [\"02\", \"baz\"] ] # sort\n # [ \"foo\", \"bar\", \"baz\" ] # map\n node_to_hash(node).to_a.sort.map(&:last)\n end",
"def nodes\n []\n end",
"def to_a\n @current = self.head\n position = self.head\n result = []\n while position do\n result << position.value.dup\n position = position.next\n break if position.equal?(@current)\n end\n result\n end",
"def all_edges\n @edges.values.inject { |arr1, arr2| arr1 + arr2 } || []\n end",
"def each\n @nodes.values.each do |node|\n yield node, node.adjacency_list\n end\n end",
"def to_array\n children.each_with_object( [ self ] ) { |child, memo|\n memo.concat( child.to_array )\n }.flatten\n end",
"def create_arr\n k = []\n n = self.first\n until n.nil? do\n if n.value.is_a? Linkedlist\n k.append(n.value.create_arr)\n else\n k.append(n.value)\n end\n n = n.next\n end\n return k\n end",
"def bnodes\n @graphs.inject([]) {|memo, g| memo += g.bnodes}\n end",
"def reduce(nodes)\n for node in nodes\n if node.class==ActiveSupport::HashWithIndifferentAccess && node['data']\n data_array = Array.new\n node['data'].map{|element| data_array << element[1]}\n node['data'] = data_array\n end\n\n if node.class==Array || node.class == ActiveSupport::HashWithIndifferentAccess\n reduce (node)\n end\n end\n end",
"def inorder\n return [] if @root.nil?\n\n nodelets_array = []\n\n inorder_helper(@root, nodelets_array)\n\n return nodelets_array\n end",
"def flat(a)\n\tnew_arr = []\n\ta.each do |el|\n\t\tif el.is_a? Array\n\t\t\tel.each do |n|\n\t\t\t\tif el.is_a? Array\n\t\t\t\t\ta << n\n\t\t\t\telse\n\t\t\t\t\tnew_arr << n\n\t\t\t\tend\n\t\t\tend\n\t\telse\n\t\t\tnew_arr << el\t\n\t\tend\n\tend\n\tp new_arr\nend",
"def to_a #preorder\n @root.to_a\n end",
"def process_all(nodes)\n results = []\n nodes.to_a.each do |node|\n n = process(node)\n if n\n if n.is_a?(Inline)\n results += n\n else\n results << n\n end\n end\n end\n results\n end",
"def optimize_depth_array()\n\n @root = @all_depths[0].first[1]\n\n # for each depth in tree\n @all_depths[1..@all_depths.length-1].each do |depth|\n # for each item in depth (could be node or array of nodes)\n depth.each do |sec_id, item|\n if (item.class == Node)\n node = item\n parent = get_parent(node.path)\n parent.add_child(node)\n else # item is array of nodes\n item.each do |node|\n parent = get_parent(node.path)\n parent.add_child(node)\n end\n end\n end\n end\n\n end",
"def to_a (root = self, array = [])\n to_a(root.left, array) unless root.left.nil?\n array << root.value\n to_a(root.right, array) unless root.right.nil?\n array\n end",
"def to_a\n results = []\n traverse { |value| results << value }\n results\n end",
"def nodes\n return @nodes if (not @nodes.nil? and @nodes.size > 0)\n init_nodes\n @nodes\n end",
"def nodes\n [@from, @to]\n end",
"def flatten\n nodes = []\n queue = [node]\n\n while node = queue.shift\n nodes << node\n queue.unshift(*node.children) unless node.leaf?\n end\n\n nodes\n end",
"def linked_list_to_array(list)\n node = list\n queue = []\n\n while node\n queue.unshift(node.val)\n node = node.next\n end\n queue\nend",
"def nodes\n @nodes = [] if !instance_variable_defined?(:@nodes) or @nodes.nil?\n @nodes\n end",
"def traverse base, arcs\n objs = [base]\n arcs.each_with_index do |arc,i|\n objs.map! { |obj| traverse_one obj, arc, i==0 }\n objs.flatten!\n end\n objs\n end",
"def nodes()\n self.root.nodes()\n end",
"def to_a\n\t\t\titems = []\n\t\t\tcurrent = self\n\t\t\t\n\t\t\twhile current.tail != self\n\t\t\t\tunless current.tail.is_a?(Iterator)\n\t\t\t\t\titems << current.tail\n\t\t\t\tend\n\t\t\t\t\n\t\t\t\tcurrent = current.tail\n\t\t\tend\n\t\t\t\n\t\t\treturn items\n\t\tend",
"def nodes\n @nodes.frozen? ? @nodes : @nodes.dup.freeze\n end",
"def concat(nodes); end",
"def to_json\n @nodes.map(&:to_json)\n end",
"def to_a\n extracted_children = children.map { |c| c.respond_to?(:to_a) ? c.to_a : c }\n extracted_children.zip(Array.new(children.length, separator)).flatten[0..-2]\n end",
"def nodes\n\t\t# Query the database\n\t\tnodeQuery = Node.select(:node_id)\n\t\t# Place the query in an array\n\t\tnodeArray = Array.new\n\t\tnodeQuery.each do |node|\n\t\t\tnodeArray.push [node.node_id]\n\t\tend\n\t\treturn nodeArray\n\tend",
"def reachable_nodes\n recursive_set(@start) { |n| n.out }\n end",
"def inorder_traversal(root)\n #Base: when root is at the end\n return [] if root.nil?\n #Declare empty array\n result = []\n #push recursive call of root.left\n result.concat(inorder_traversal(root.left))\n #push root vale itself\n result << root.val\n #push recursive call of root.right\n result.concat(inorder_traversal(root.right))\n # return result \n result\nend",
"def map &block\n cola = []\n cola << self\n while(!cola.empty?) \n node = cola.shift\n yield node \n node.each do |child|\n cola << child unless child == nil\n end\n end\n\n end",
"def to_a\n root.to_a\n end",
"def get_all_operations\n list = []\n queue = Queue.new\n queue << node\n until queue.empty?\n n = queue.pop\n puts \"NODE: \" + n.to_s\n if n.operation != NodeOperation::NODE\n list.push(n)\n n.nodes.each do |sub_node|\n queue << sub_node\n end\n end\n end\n list\n end",
"def all_paths_source_target(graph, results=[], current_node=0, current_path=[])\n if current_node == graph.length - 1\n return results << (current_path + [current_node])\n end\n\n graph[current_node].each do |node|\n all_paths_source_target(graph, results, node, (current_path + [current_node]))\n end\n\n return results\nend",
"def all_children_deep(flag=nil)\n\t\tarr = []\n\t\tall_children(flag).each do |c|\n\t\t\tarr << c\n\t\t\tc.all_children_deep(flag).each do |cc|\n\t\t\t\tarr << cc\n\t\t\tend\n\t\tend\t\t\t\n\t\tarr\n\tend",
"def to_adj\n full_jsivt= []\n @nodes.each do |id, node_data|\n name = node_data[@name_key]\n data = node_data[:data]\n adjacencies = node_data[@children_key]\n jsivt = {}\n jsivt[\"id\"] = id\n jsivt[\"name\"] = name || \"id: #{id}\" #if no name show id\n jsivt[\"data\"] = data\n jsivt[\"adjacencies\"] = adjacencies\n full_jsivt << jsivt\n end \n full_jsivt.to_json \n end",
"def all_in_tree\n accounts = Array.new\n accounts += ancestors\n accounts += sibling_accounts\n accounts += children\n accounts << self\n return accounts\n end",
"def get_all_edges(course)\n edges = []\n edges.push({node.id_to_s => course.id_to_s})\n queue = Queue.new\n queue << node\n\n until queue.empty?\n n = queue.pop\n n.nodes.each do |sub_node|\n node_id = n.id_to_s\n subnode_id = sub_node.id_to_s\n edges.push({subnode_id => node_id})\n\n if sub_node.operation != NodeOperation::NODE\n queue << sub_node\n end\n end\n end\n edges\n end",
"def children\n arr = []\n board.rows.each_with_index do |row, i|\n row.each_with_index do |ele, j|\n if board.empty?([i,j])\n cur_board = board.dup \n cur_board[[i,j]] = next_mover_mark\n if next_mover_mark == :o\n next_mark = :x\n else\n next_mark = :o\n end\n node = TicTacToeNode.new(cur_board, next_mark, [i,j])\n arr << node\n end\n end\n end\n arr\n end",
"def nodes_inorder\n ret = []\n inorder(root, ret)\n ret\n end",
"def build_from_data(data)\n data.each do |list_data|\n adjacent_list = AdjacentList.new\n list_data.reduce do |ele1, ele2|\n node2 = Node.new(ele2)\n\n if ele1.is_a?(Node)\n ele1.next_node = node2\n else\n node1 = Node.new(ele1, node2)\n adjacent_list.head_node = node1\n self.dict[node1.value] = self.adj_list_array.length\n end\n # return node2 to next reduce iteration\n node2\n end\n self.adj_list_array.push(adjacent_list)\n end\n end",
"def map! &block\n cola = []\n cola << self\n while(!cola.empty?) \n node = cola.shift\n node.n = yield node \n node.each do |child|\n cola << child unless child == nil\n end\n end\n end",
"def connectable_nodes_from(nodes)\n @calls << [:connectable_nodes_from, nodes]\n nodes & @accept_nodes\n end",
"def adjacency_list\n list = []\n list << self * 2 unless @parent == self * 2 or self * 2 > @@roof\n list << self / 2 unless self.odd? or @parent == self / 2\n list << self + 2 unless self + 2 > @@roof\n list\n end",
"def to_a(options = {})\n omit = options[:omit] || []\n node = @node.to_a(options) unless @node.nil? || omit.include?(:node)\n # this may need to be cached when properties are updated\n # might be worth benchmarking\n [\n start_byte,\n node,\n @data,\n end_byte\n ].compact\n end",
"def get_results(with_root = false)\n ret = []\n\n # Iterate over all occupied descendants and create chain data\n @occupied_descendants.each do |node|\n ret << [node.data, node.get_chain(with_root)]\n end\n\n # Return\n ret\n end",
"def all\n result = []\n\n queue = []\n current_node = self.find_root\n queue << current_node\n\n until queue.empty?\n current_node = queue[0]\n result << current_node.val\n # use empty nodes to maintain two-childs for each node so it's easier to read the array output\n if current_node.val != \"E\"\n if current_node.left\n queue << current_node.left\n else\n # only insert an empty node when the other branch exists\n # prevents excessive empty nodes for external nodes\n queue << BSTNode.new(\"E\", parent = current_node) if current_node.right\n end\n if current_node.right\n queue << current_node.right\n else\n # only insert an empty node when the other branch exists\n # prevents excessive empty nodes for external nodes\n queue << BSTNode.new(\"E\", parent = current_node) if current_node.left\n end\n end\n queue.shift\n end\n\n result\n end",
"def traverseNodes(nodes, nextNode)\n tVec = Array.new\n #puts \"***********************\\ntraverseNodes :#{nextNode} \\n_______________________________\\n#{nodes}\\n***********************************\"\n for i in 0..nodes.size\n tmp = nodes[i]\n @xmlTool.setCountToZero()\n at = 0\n #tmpNode = @xmlTool.getHashForNameAtPos(tmp, nextNode, at)\n while ((tmpNode =@xmlTool.getHashForNameAtPos(tmp, nextNode, at) )!= nil)\n at = at.next\n @xmlTool.setCountToZero()\n tVec.push(tmpNode) # alternative is tVec.push(tmpNode)\n #tmpNode = @xmlTool.getHashForNameAtPos(tmp, nextNode, at)\n end\n end\n return tVec\n end",
"def children\n array = []\n @board.rows.each do |row|\n @board.row.each do |el|\n if el.empty?\n new_board = @board.dup\n new_board[row][el] = @next_mover_mark\n prev_move = [row, el]\n new_node = TicTacToeNode.new(new_board, alternate_mover_mark, prev_move)\n array << new_node\n end\n end\n end\n array\n end",
"def nodes\n @conn.nodes\n end",
"def all\n root.to_a\n end",
"def children\n node_arr = []\n (0..2).each do |row|\n (0..2).each do |col|\n if @board.empty?([row, col])\n updated_board = @board.dup\n updated_board[[row, col]] = @next_mover_mark\n updated_positions = @prev_move_pos.dup\n updated_positions += [row, col]\n node_arr << TicTacToeNode.new(updated_board, @next_mover_mark == :o && :x || :o, updated_positions) \n end\n end\n end\n node_arr\n end",
"def inorder_traversal_i(root)\n # declare a queue (Stack)'\n # declare an array variable\n # until root.value.nil? \n # push all the left nodes to the stack\n # once reach to root.value, push stack value to array \n arr = []\n stack = Queue.new \n currentNode = root\n while (!currentNode.nil? || !stack.empty?)\n while !currentNode.nil?\n stack.push(currentNode)\n currentNode = root.left\n end \n currentNode = stack.pop \n arr.push(currentNode.val)\n currentNode = currentNode.right \n end \n return arr\n\nend",
"def _all_nodes(this_db = self.started_db)\n Enumerator.new(this_db, :_each_node)\n end",
"def nodes; end",
"def nodes; end",
"def nodes; end",
"def dfs(target)\n return self if self.value == target\n # debugger\n self.children.each do |node|\n dfs(node)\n # if node.value == target\n # return node\n # else\n # node.dfs(target)\n # end\n end\n return nil if self.children.empty?\n p new_arr\n end",
"def nodes\n @current\n end",
"def all_nodes(this_db = self.started_db)\n Enumerator.new(this_db, :each_node)\n end",
"def flatten_a_o_a(aoa)\n result = []\n x = 0\n while x < aoa.length do\n y = 0\n while y < aoa[x].length do\n result.push(aoa[x][y])\n y += 1\n end\n x += 1\n end\n return result\nend",
"def to_array\n parents = []\n\n top_array = [self]\n c_arr = top_array\n\n self.class.base_class.each_with_level(descendants.includes(:link => :linkable)) do |menu, level|\n case level <=> parents.count\n when 0 # same level\n # set current array as new sibling array containing menu\n c_arr = [menu] \n\n # and push current array (the new sibling array) to current parent\n parents.last[1] << c_arr \n\n when 1 # descend\n # push a child array if the current level does no thave one\n c_arr << [] if c_arr.length == 1\n \n # and push the sibling array into that array\n c_arr[1] << [menu]\n\n # push the current array to be the current parent\n parents << c_arr\n\n # and reset the current as the new child array\n c_arr = c_arr[1].last\n\n when -1 # ascend\n # pop parents up to the parent of the new menu\n parents.pop while parents.count > level\n\n # and proceed to add new sibling as though level had been 0\n c_arr = [menu]\n parents.last[1] << c_arr\n end\n end\n\n top_array\n end",
"def subgraphs\n subs = []\n nodes_to_hit = @vertices.dup\n until nodes_to_hit.empty?\n subgraph = subgraph_with(nodes_to_hit.to_a.first)\n subs << subgraph\n nodes_to_hit -= subgraph.vertices\n end\n subs\n end",
"def shortest_path_to_all_nodes(initial)\n initial.distance = 0\n\n current = initial\n loop do\n unvisited.delete(current)\n\n calculate_neighbor_shortest_distances(current)\n\n return graph.vertices if no_reachable_nodes\n\n current = unvisited.min_by(&:distance)\n end\n end",
"def fill(node)\n filled_so_far = Array.new\n nodes_hash = Hash.new\n already_seen = Hash.new\n queue = [node]\n while (not queue.empty?)\n next_node = queue.shift\n next if already_seen[next_node]\n already_seen[next_node] = true\n @paths[next_node].each do |next_next_node|\n if (next_next_node == next_node)\n # special case. we consider a node connected to itself to be strongly connected\n nodes_hash[next_node] = true\n elsif (find(next_next_node,next_node)) \n # make sure there is a reverse path\n queue << next_next_node\n nodes_hash[next_node] = true\n nodes_hash[next_next_node] = true\n end\n end\n end\n nodes = nodes_hash.keys\n @paths.each do |k,v|\n if nodes.include?(k)\n v.each do |v|\n if nodes.include?(v)\n filled_so_far << [k,v]\n end\n end\n end\n end\n return filled_so_far\n end",
"def fill(node)\n filled_so_far = Array.new\n nodes_hash = Hash.new\n already_seen = Hash.new\n queue = [node]\n while (not queue.empty?)\n next_node = queue.shift\n next if already_seen[next_node]\n already_seen[next_node] = true\n @paths[next_node].each do |next_next_node|\n if (next_next_node == next_node)\n # special case. we consider a node connected to itself to be strongly connected\n nodes_hash[next_node] = true\n elsif (find(next_next_node,next_node)) \n # make sure there is a reverse path\n queue << next_next_node\n nodes_hash[next_node] = true\n nodes_hash[next_next_node] = true\n end\n end\n end\n nodes = nodes_hash.keys\n @paths.each do |k,v|\n if nodes.include?(k)\n v.each do |v|\n if nodes.include?(v)\n filled_so_far << [k,v]\n end\n end\n end\n end\n return filled_so_far\n end",
"def get_values_for_verification\n \t@intermediate_nodes = self.get_intermediate_nodes\n @array = []\n\n @intermediate_nodes.each do |node|\n @array << node.sha.to_s\n if node.is_right_child\n @array << \"rchild\"\n else\n @array << \"lchild\"\n end\n end\n\n \t@array << Node.get_root_node.sha.to_s\n @array << \"root\"\n\n \treturn @array\n #return @intermediate_nodes\n end",
"def connected_component\n sa = []\n queue = []\n visited = []\n\n queue.push self.id\n visited.push self.id\n\n while not queue.empty?\n answer_id = queue.shift\n\n answer = Answer.find(answer_id)\n sa << answer_id\n\n for similar_answer in answer.similar_answers do\n unless visited.include?(similar_answer)\n queue.push similar_answer\n visited.push similar_answer\n end\n\n end\n end\n sa\n end",
"def children\n\n children_array = []\n @board.rows.each_index do |row_idx|\n @board.rows[row_idx].each_index do |col_idx|\n if @board[[row_idx, col_idx]].nil?\n dup_board = @board.dup\n dup_board[[row_idx, col_idx]] = @next_mover_mark\n next_next_mark = switch_mark\n children_array << TicTacToeNode.new(dup_board, next_next_mark, [row_idx, col_idx])\n end\n end\n end\n children_array\n end",
"def connections_to(node)\n node = get_index_from_node(node)\n @adj_mat.map {|row| row[node] }.map.with_index do|el, row_num| \n el == 0 ? nil : @nodes[row_num]\n end.select{ |el| el } \n end",
"def connections_to(node)\n node = get_index_from_node(node)\n @adj_mat.map {|row| row[node] }.map.with_index do|el, row_num| \n el == 0 ? nil : @nodes[row_num]\n end.select{ |el| el } \n end",
"def nodes\n left_nodes + [self] + right_nodes\n end",
"def arr(n)\n\n return [n] if !n.kind_of?(Array)\n\n butts = []\n\n n.each do |ele|\n\n butts += arr(ele)\n end\n\n # if n.kind_of?(Array) == false\n # butts << n\n \n # else\n # arr(n[0])\n # end\n\n butts\n \n\nend",
"def traverse(root, ar)\n if root\n traverse(root.left, ar)\n traverse(root.right, ar)\n ar << root.val\n end \nend",
"def postorder\n nodelets_array = []\n\n postorder_helper(@root, nodelets_array)\n \n return nodelets_array\n end"
] |
[
"0.7012965",
"0.6966498",
"0.68051904",
"0.6770991",
"0.6724855",
"0.65954775",
"0.6266293",
"0.62211686",
"0.6193075",
"0.6148097",
"0.6112715",
"0.60460734",
"0.602377",
"0.5986071",
"0.5983784",
"0.5983784",
"0.5901126",
"0.5877439",
"0.5841594",
"0.58410764",
"0.5788534",
"0.5773878",
"0.57716763",
"0.5760729",
"0.575671",
"0.5750114",
"0.57425946",
"0.57264477",
"0.5719075",
"0.5716067",
"0.57042265",
"0.56766635",
"0.56689906",
"0.562187",
"0.56141347",
"0.55982137",
"0.5590659",
"0.5581557",
"0.5576035",
"0.55681247",
"0.5563791",
"0.5560404",
"0.55523854",
"0.5550067",
"0.5540755",
"0.553567",
"0.5527935",
"0.55272245",
"0.55262727",
"0.5508866",
"0.55034673",
"0.54725903",
"0.5453703",
"0.5446679",
"0.5442384",
"0.5440187",
"0.5435955",
"0.5408975",
"0.54046965",
"0.53987145",
"0.53904414",
"0.5388664",
"0.53881973",
"0.5383506",
"0.53746986",
"0.53541803",
"0.53508145",
"0.5346675",
"0.53457767",
"0.53440833",
"0.534327",
"0.53424484",
"0.5339209",
"0.53364325",
"0.5328042",
"0.5327059",
"0.53224474",
"0.5320661",
"0.53195035",
"0.5318067",
"0.5318067",
"0.5318067",
"0.5314826",
"0.5311444",
"0.53106546",
"0.53092617",
"0.5307494",
"0.5306919",
"0.5292738",
"0.52925736",
"0.52925736",
"0.52783775",
"0.52766955",
"0.5276324",
"0.52741456",
"0.52741456",
"0.5270053",
"0.5267586",
"0.5264416",
"0.52608824"
] |
0.66655356
|
5
|
Initialize CWLSLas object passing las file as argument Example: >> my_well = CWLSLas.new('my_well.las') => Arguments: las_file_name: (String) file_options: (Hash) options: encoding
|
def initialize(filename=nil, file_options={})
load_file(filename, file_options) if not filename.nil?
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def initialize(file_or_path, options = {})\n data = file_or_path.read if file_or_path.respond_to?(:read)\n data ||= File.read file_or_path\n\n @keystore = options[:keystore]\n\n init(data)\n end",
"def initialize(options)\n options.each { |k, v| self.send :\"#{k}=\", v }\n self.file = File.expand_path file\n end",
"def initialize(file_name, config = Crossref::Config)\n @file_name = file_name\n @config = config.load_config\n end",
"def initialize(file_name, encoding = nil)\n end",
"def initialize(file)\n @file = file\n end",
"def initialize(file)\n @file = file\n end",
"def initialize(file)\n @file = file.is_a?(String) ? File.open(file) : file\n end",
"def initialize(file)\n @file = file.is_a?(String) ? File.open(file) : file\n end",
"def initialize(file)\n @file = file.is_a?(String) ? File.open(file) : file\n end",
"def initialize(file=nil)\n @files = []\n @deps = []\n @libs = []\n @inc_paths = []\n @lib_paths = []\n from_s Utils::read_file file if !file.nil?\n end",
"def initialize(file)\n @file = File.expand_path(file)\n fail \"Can't find file #{@file}\" unless File.exist?(@file)\n @dir = File.dirname(@file)\n IO.readlines(@file).each { |line| initialize_data line }\n @configuration = Configuration.new(self)\n @semver = Versioning.find(@dir)\n end",
"def initialize(filename)\n @filename = filename\n end",
"def initialize(filename)\n @filename = filename\n end",
"def initialize(filename)\n @filename = filename\n end",
"def initialize(file, options={})\n @file = file\n\n @mode = options[:mode]\n @applique = options[:applique]\n end",
"def initialize(file, options = {})\n # merge the options together\n @@options.merge!(options.kind_of?(Hash) ? options : {})\n \n # check that the path ends with a /\n if @@options['path'][-1, 1] != '/'\n @@options['path'] += '/'\n end\n \n # normalize the filename\n file = File.basename(file)\n \n # make sure chunkSize is an int\n @@options['chunkSize'] = @@options['chunkSize'].to_i()\n \n # check it's valid\n unless @@options['chunkSize'] >= 64\n @@options['chunkSize'] = 512\n end\n \n # set the filename\n @@file = File.expand_path(@@options['path'] + file)\n \n # check the file exists\n unless File.exists?(@@file)\n raise Exception.new('Cannot load file: ' + @@file)\n end\n \n # open the file\n @@handle = File.new(@@file, 'r')\n \n # check the file opened successfully\n unless @@handle\n raise Exception.new('Error opening file for reading')\n end\n \n # add a __destruct style method\n ObjectSpace.define_finalizer(self, self.class.method(:finalize).to_proc)\n end",
"def initialize(file_path)\n @file_path = file_path\n end",
"def initialize(file)\n @file = file\n end",
"def initialize(file)\n @file = file\n end",
"def initialize(file)\n @file = file\n end",
"def initialize(file_path)\n\t\tbegin\n\t\t\t@file_desc = File.open(file_path)\n\t\trescue\n\t\t\traise \"File not found\"\n\t\tend\n\tend",
"def initialize(files, options = {})\n @files = files\n @options = options\n end",
"def initialize(options = {})\n @filename = options[:file]\n @ledger = options[:bin] || 'ledger'\n end",
"def initialize(file_name, stream = T.unsafe(nil), encrypter = T.unsafe(nil)); end",
"def initialize(filename)\n @fname = filename\n end",
"def initialize filename\n\t\t@filename = filename\n\tend",
"def initialize(filename)\n @filename = filename\n end",
"def initialize(filename)\n @filename = filename\n end",
"def initialize(file)\n @file = file\n end",
"def initialize(filename=nil,clean=false)\n\t\tif filename.nil?\n\t\t\t@clusters = []\n\t\t\t@items = []\n\t\telsif filename.is_a?(Hash)\n\t\t\tload_from_hash(filename)\n\t\telsif filename =~ /ya?ml$/\n\t\t\ttemp = YAML.load_file(filename)\n\t\t\tif temp.is_a?(Clustering)\n\t\t\t\t@clusters = temp.clusters\n\t\t\t\t@items = temp.items\n\t\t\telsif temp.is_a?(Hash)\n\t\t\t\tload_from_hash(temp)\n\t\t\tend\n\t\telse # Load from custom file format\n\t\t\tload_from_file(filename,clean)\n\t\tend\n\tend",
"def initialize(filename)\n @path = filename\n end",
"def initialize(options = {})\n @options = options.stringify_keys.reverse_merge('size' => DEFAULT_SIZE, 'path' => DEFAULT_PATH)\n initialize_file\n end",
"def initialize(swc_file)\n\t\tsuper(swc_file, FlexSDK::compc)\n\tend",
"def initialize(file_name, initial_data = {})\n @file_name = file_name\n super initial_data\n end",
"def initialize(file_path)\n\t\t@path = file_path\n\tend",
"def initialize(config, facility, location, zip_file_name, inbound_file_information = nil)\n @config_yml = YAML::load(File.open(config))\n @facility = facility\n @location = location\n @zip_file_name = zip_file_name\n @inbound_file_information = inbound_file_information\n end",
"def initialize iss_file, properties\n @iss_file = iss_file\n @source = properties['Source']\n @flags = (properties['Flags'] || '').split(' ')\n @dest_dir = properties['DestDir']\n @excludes = (properties['Excludes'] || '').split(',')\n @components = (properties['Components'] || '').split(' ')\n end",
"def initialize\n options = Docopt::docopt(doc)\n @filename = options.delete('<filename.sls>')\n\n raise Docopt::Exit, 'File not exists' unless File.exist?(@filename)\n raise Docopt::Exit, 'File has a wrong format' unless @filename =~ /\\.sls\\Z/\n\n options.each do |dashed_k, v|\n k = dashed_k[2..dashed_k.length]\n instance_variable_set(\"@#{k}\".to_sym, v)\n end\n end",
"def initialize(fileName_vars)\n @fileName_vars = fileName_vars\n end",
"def initialize(file_name)\n @file_name = file_name\n init_matrix(file_name)\n end",
"def initialize(file, game)\n @file = file\n @game = game\n end",
"def initialize(config, *args)\n file_type = config[:file_type]\n @symmetric_key = config[:symmetric_key]\n @schemas = ::NmDatafile::SCHEMA[:schemas]\n set_file_type(file_type)\n \n load_data(args)\n \n setup_object_for_schema\n end",
"def initialize(file,settings={})\n\t\t@file = file\n\t\t@settings = settings\n\tend",
"def initialize(file_name)\n create(file_name)\n end",
"def initialize(source)\n @source = File.expand_path(source)\n end",
"def initialize(ms_off_crypto)\n @file_name = ms_off_crypto.file_name \n @ms_off_crypto = ms_off_crypto\n create_storages\n mini_fat_stream\n mini_fat\n fat\n header\n end",
"def initialize(filename = nil, map_filename = nil)\n self.load_config(filename)\n self.load_map(map_filename)\n end",
"def initialize(input_file)\n @input_file = input_file\n @source = File.new(input_file)\n end",
"def initialize(filename)\n @filename = filename\n extension = ::File.extname(@filename)\n @format = load_format(extension)\n @name = ::File.basename(@filename, extension)\n @data = ::File.open(@filename, 'rb') { |f| f.read } if valid? && ::File.exists?(@filename)\n end",
"def initialize(filename, highway_attributes)\n\t\t@filename = filename\n\t\t@highway_attributes = highway_attributes \n\tend",
"def initialize(filename, highway_attributes)\n\t\t@filename = filename\n\t\t@highway_attributes = highway_attributes \n\tend",
"def initialize iss_file, properties\n @iss_file = iss_file\n @name = properties['Name']\n end",
"def initialize(name)\n @fh = File.open(name, 'r')\n end",
"def initialize(filename, highway_attributes)\n @filename = filename\n @highway_attributes = highway_attributes\n end",
"def initialize(file)\n @file = file\n @options = {}\n @original_options = {}\n read\n end",
"def initialize(data, current_file: nil, **options)\n begin\n current_file ||= Download.open_each(data, unzip: FILE_PATTERNS, downcase: true, tmpdir: options[:tmpdir]).first\n rescue Unzip::PathNotFound\n raise ImportError, INVALID_ARCHIVE\n end\n\n case ::File.extname(current_file.path.downcase)\n when '.kml'\n __setobj__(KMLFile.new(current_file, **options))\n when '.shp'\n __setobj__(Shapefile.new(current_file, **options))\n when '.json', '.geojson'\n __setobj__(ESRIGeoJSON.new(current_file.path, **options))\n else\n raise ImportError, \"Could not import file. \" + SUPPORTED_FORMATS\n end\n end",
"def initialize(args={})\n @file = args[:file]\n filepath = args[:filepath]\n unless @file || !filepath\n @file = ::File.open(filepath)\n end\n string = args[:string]\n unless @file || !string\n @file = StringIO.new(string, 'r')\n end\n post_initialize(args)\n end",
"def initialize(filename=nil)\n @version = [0,0,0]\n read(filename) unless filename.nil?\n end",
"def initialize(filename, options = {})\n if options[:preload] || !IO.respond_to?(:pread)\n @mutex = Mutex.new\n end\n\n @use_pread = IO.respond_to?(:pread) && !options[:preload]\n\n @options = options\n @database_type = Edition::COUNTRY\n @record_length = STANDARD_RECORD_LENGTH\n @file = File.open(filename, 'rb')\n\n detect_database_type!\n\n preload_data if options[:preload]\n end",
"def initialize(args={})\n @quiet = args.delete(:quiet) || false\n @lastore = File.expand_path(args.delete(:lastore)|| \"~/.config/lapack\")\n @ladb = \"db\"\n @lapkg = \"pkg\"\n FileUtils.mkdir_p(dbs_store)\n\n raise \"Unknown args #{args.keys.join(', ')}\" unless args.keys.empty?\n end",
"def initialize(filename)\n super(filename, EXT)\n end",
"def initialize(filename)\n super(filename, EXT)\n end",
"def initialize(filename)\r\n @filename = filename\r\n @base_filename = File.basename(filename)\r\n @filepath = File.dirname(filename)\r\n @category = nil\r\n find_category\r\n @language = nil\r\n find_language\r\n @errors = nil\r\n @number_properties = nil\r\n end",
"def initialize(filename)\n @data_file = File.expand_path(filename)\n @track_header = UCSC::TrackHeader.new(:type => 'wiggle_0')\n @index = WigIndex.new\n end",
"def initialize(filename=nil)\n self.load(filename) if filename\n @schema = nil\n end",
"def initialize(filename, read_properties=true)\n end",
"def initialize(filename, read_properties=true)\n end",
"def initialize\r\n\r\n I18n.exception_handler = I18n::LinguaFrancaMissingTranslation.new\r\n unless File.exist?(I18n.config.info_file)\r\n dir = File.dirname(I18n.config.info_file)\r\n FileUtils.mkdir_p(dir) unless File.directory?(dir)\r\n File.open(I18n.config.info_file, 'w+')\r\n end\r\n\r\n # throw an exception if we're missing the pluralizations rules file\r\n throw Exception(\"Lingua Franca: Missing Pluralization File #{I18n.config.languages_file}\") unless File.exist?(I18n.config.languages_file)\r\n \r\n super\r\n end",
"def initialize(args)\n @filename = args.fetch(:filename, nil)\n @yamlstring = args.fetch(:yamlstring, nil)\n \n unless defined?(@filename) || defined?(@string)\n raise InitializationError.new \"you must give me a filename or a string of YAML to get started\"\n end\n\n \n \n \n end",
"def initialize(filename, options = nil)\n @path = nil\n @debug = false\n unless options.nil?\n unless options.is_a?(Hash)\n raise ArgumentError, 'Second argument must be Nil or a Hash.'\n end\n @path = options[:custom_path] unless options[:custom_path].nil?\n @debug = options[:debug] unless options[:debug].nil?\n end\n @strings = parse(filename, @path)\n end",
"def initialize(*files)\n @files = files\n\n @_config = Hash.new{ |h,k| h[k]=[] }\n #@_onload = Hash.new{ |h,k| h[k]=[] }\n\n load_files(*files)\n end",
"def initialize(source, filename, options = {})\n #source += \"\\n\" unless source.end_with?(\"\\n\")\n @source, @filename, @options = source, filename, options\n @requires = []\n @required_trees = []\n end",
"def initialize(file = nil)\n @file_name = file ? file : File.join(Dir.home, '.dodona.yml')\n @config = if !File.exist? file_name\n {}\n else\n YAML.load_file file_name\n end\n @config = DEFAULTS.merge(@config)\n end",
"def initialize(file_name)\n @file_name = file_name\n @file_hash = file_hash(file_name)\n @params = Hash.new\n end",
"def initialize file\n EasyTranslate.api_key = 'AIzaSyDrbD0AfKHiMZTYoite-ec4byLNlPxoX8k'\n @file = file\n @properties = []\n \n File.open(file, \"r:UTF-8\").each do |line| \n @properties << line \n end\n end",
"def initialize(options = {})\n @file = options[:file]\n @text = options[:text]\n @url = options[:url]\n end",
"def initialize data, file=nil\n @data = data\n @file = file\n end",
"def initialize(file, opts = {})\n load_specifics(file)\n @file = file\n @info = @raw = read\n @opts = opts\n post_initialize if respond_to?(:post_initialize)\n end",
"def initialize(filename)\n super(filename);\n @@this = self;\n end",
"def initialize(file = nil, &b)\r\n \r\n @rules = {}\r\n @facts = {}\r\n @dependencies = {}\r\n \r\n if block_given?\r\n instance_eval(&b)\r\n elsif file\r\n # loading a file, check extension\r\n name,ext = file.split(\".\")\r\n logger.debug(\"loading ext: #{name}.#{ext}\") if logger\r\n case ext\r\n when 'csv'\r\n load_csv( file )\r\n \r\n when 'xml'\r\n load_xml( file )\r\n \r\n when 'rb'\r\n load_rb( file )\r\n \r\n when 'rules' # for backwards compatibility\r\n load_rb(file)\r\n \r\n else\r\n raise RuleLoadingError, \"invalid file extension: #{ext}\"\r\n end\r\n end\r\n end",
"def initialize(source, options); end",
"def initialize(filename)\n\t\tbegin\n @sourcefile = filename\n \n\t\t\tFile.open(filename, \"r\") do |objfile|\n\t\t\t\tunless getl(objfile) == \"LINK\"\n\t\t\t\t\tputs \"Invalid file format: \" + filename\n\t\t\t\t\treturn nil\n\t\t\t\tend\n\n\t\t\t\t# Read header info\n\t\t\t\t@nsegs, @nsyms, @nrlocs = getl(objfile).split(' ').collect {|x| x.to_i}\n\t\t\t\t\n\t\t\t\t# Parse segs\n\t\t\t\t@segrecs = [], @segnames = {}\n\t\t\t\tgather_segs(objfile)\n\t\t\t\t\n\t\t\t\t# Parse symbols\n\t\t\t\t@symrecs = [], @symnames = {}\n\t\t\t\tgather_syms(objfile)\n\t\t\t\t\n\t\t\t\t# Parse relocations\n\t\t\t\t@rlocrecs = []\n\t\t\t\tgather_rlocs(objfile)\n\t\t\t\t\n\t\t\t\t# Slurp in data\n\t\t\t\t@segrecs.select {|seg| /P/===seg[:type]}.each do |seg|\n\t\t\t\t\tseg[:data] = getl(objfile).hex2bin\n\t\t\t\tend\n\n\t\t\tend\n\t\trescue\n\t\t\tputs \"Could not open object file: \" + filename\n\t\tend\n\tend",
"def load_from_file(file, options = T.unsafe(nil)); end",
"def initialize(file)\n @data = { :students => [] }\n @file = file\n load_data\n end",
"def initialize(file_name, dir = default_dir)\n @dir = dir\n @file_name = file_name\n end",
"def initialize(filename, verbose)\n \n begin\n @file = File.open(filename, 'r') {|f| f.read}\n puts Compiler::color_out(\"Opened file #{filename}\", :green) if @verbose\n rescue Exception => ex\n puts Compiler::color_out(\"[error] Couldn't open file #{filename}\", :red)\n end\n \n # Marks the next character to be read in the file.\n @pos = 0\n \n # Counter for the line.\n @line = 0\n \n # Counter for the column.\n @column = 0\n \n # Holds the option that was passed.\n @verbose = verbose\n\n end",
"def initialize(filename=nil, options={})\n if filename.is_a?(Hash)\n options = filename\n filename = nil\n end\n @filename = filename\n @escapefunc = options[:escapefunc] || ESCAPE_FUNCTION\n @preamble = options[:preamble] == true ? \"_buf = #{init_buf_expr()}; \" : options[:preamble]\n @postamble = options[:postamble] == true ? \"_buf.to_s\" : options[:postamble]\n @args = nil # or array of argument names\n convert_file(filename) if filename\n end",
"def initialize(config_yml_file, facility, location, zip_file_name,inbound_file_information)\n @config_yml = config_yml_file\n @facility = facility\n @parser = @facility.index_file_parser_type.to_s.downcase.split('_')[0]\n @sitecode = @facility.sitecode.to_s.strip.upcase\n @location = location\n @zip_file_name = zip_file_name\n @client = facility.client\n @@batch_date = Date.today if !defined?(@@batch_date)\n @hash_envelop_images = {}\n @hash_envelop_value = 0\n @inbound_file_information = inbound_file_information \n end",
"def initialize(args = {})\n @file = args[:file] if args[:file]\n @dictionary = args[:dictionary] if args[:dictionary]\n end",
"def initialize(file_name: nil, file_extension: DefaultConstants::EXTENSION, convert: false, output: DefaultConstants::FILE_PATTERN)\n @file_name = file_name ### source file name (full path should be provided)\n @file_extension = file_extension ### file extension\n @data = [] ### file rows data\n @smart_convert = convert ### convert readed data in array of hashes with file headers keys - false by default\n @file_headers = nil ### file headers array\n @read_flag = false ### service flag\n @output = output ### write file name with extension\n end",
"def initialize(file)\n super\n @io = IRB::MagicFile.open(file)\n @external_encoding = @io.external_encoding\n end",
"def initialize filename, options = {}\n @files = []\n @options = CommandLineOptions.new.merge options\n @filename = filename\n end",
"def initialize(path)\n @data = YAML.load_file(path)\n end",
"def initialize(in_file)\n @file = File.new(in_file, \"a+\")\n @filename = in_file\n end",
"def initialize(format, options = {})\n @options = options\n @file_format = format\n end",
"def initialize(filepath = nil)\n @path = filepath ? File.expand_path(filepath.to_s) : nil\n load\n end",
"def initialize(path, language)\n @path = path\n @language = language\n end",
"def initialize(file)\n @file = parse(file)\n end",
"def initialize path\n # make menu instance accessible by the class\n @@menu = self\n @rolls = {}\n @sources = []\n\n # load a yaml file\n load_from_file path\n\n # create objects from the menu\n set_sources\n set_roll_models\n set_rolls\n end",
"def set_crl_file(opts)\n opts = check_params(opts,[:crls])\n super(opts)\n end"
] |
[
"0.61706287",
"0.6159244",
"0.6005976",
"0.59396875",
"0.588578",
"0.588578",
"0.5879552",
"0.5879552",
"0.5879552",
"0.5865736",
"0.5858681",
"0.58512884",
"0.58512884",
"0.58512884",
"0.5815233",
"0.58008766",
"0.5799979",
"0.576145",
"0.576145",
"0.576145",
"0.57358986",
"0.57346416",
"0.5733092",
"0.572652",
"0.57250124",
"0.567772",
"0.5675814",
"0.5675814",
"0.5650269",
"0.5636616",
"0.5627145",
"0.56116444",
"0.5572247",
"0.5560523",
"0.5555347",
"0.5526426",
"0.55185133",
"0.55054903",
"0.5500345",
"0.5489356",
"0.5483352",
"0.54758644",
"0.5471589",
"0.54607743",
"0.543842",
"0.5433826",
"0.5414743",
"0.5412312",
"0.5408759",
"0.53998214",
"0.53998214",
"0.5396581",
"0.5392291",
"0.53911626",
"0.5389269",
"0.5382591",
"0.5376559",
"0.5371138",
"0.53693235",
"0.5364014",
"0.5363811",
"0.5363811",
"0.53623605",
"0.53505975",
"0.53504467",
"0.53495973",
"0.53495973",
"0.53485584",
"0.5345531",
"0.53418654",
"0.5337772",
"0.53312725",
"0.53275865",
"0.5320841",
"0.53171176",
"0.5313626",
"0.53121424",
"0.53099436",
"0.5309886",
"0.5303942",
"0.53011453",
"0.5285549",
"0.5283654",
"0.528226",
"0.5267505",
"0.52669454",
"0.5265656",
"0.5264152",
"0.5264088",
"0.52606773",
"0.5257689",
"0.52553254",
"0.52509373",
"0.52498925",
"0.52469426",
"0.52370596",
"0.52356803",
"0.5230615",
"0.52260286",
"0.52252406"
] |
0.6415842
|
0
|
Return a list of mnemonics representing the curve names Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.curve_names => ["ILD", "ILM", "DT", "NPHI", "RHOB", "SFLA", "SFLU", "DEPT"]
|
def curve_names
self.curves.keys
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def names\n @mplab_pin.names\n end",
"def standarized_coeffs\n assign_names(@coeffs_stan)\n end",
"def curve(curve_name)\n self.curves[curve_name]\n end",
"def names; end",
"def names; end",
"def names; end",
"def names; end",
"def names; end",
"def names; end",
"def names; end",
"def names\n case name\n when \"Road\"\n [nil, \"\", 'Circuit', \"Criterium\", \"Road\", \"Time Trial\", \"Singlespeed\", \"Tour\"]\n when \"Mountain Bike\"\n ['Downhill', 'Mountain Bike']\n else\n [name]\n end\n end",
"def names\n map(&:names).flatten\n end",
"def names\n all.map { |item| item.name_sym }\n end",
"def names\n [\n \"Charge de travail\" , #00\n \"Travail en groupe\" , #01\n \"Maths\" , #02\n \"Codage\" , #03\n \"Théorique\" , #04\n \"Technique\" , #05\n \"Satisfaction\" , #06\n \"Dur à valider\" , #07\n \"Fun\" , #08\n \"Pipo\" , #09\n \"Économie\" , #10\n \"fondamental\" , #11\n \"Difficile à suivre\" , #12\n \"Calcul\" , #13\n \"Professionalisant\" , #14\n \"Étendue du cours\" , #15\n \"Interactivité\" , #16\n \"Culture générale\" , #17\n ]\n end",
"def curve_name\n if self.ec?\n @spki.public_key.group.curve_name\n else\n raise R509::R509Error, 'Curve name is only available with EC SPKIs'\n end\n end",
"def names\n map(&:name)\n end",
"def policy_list_names\r\n\t\tpost= { \"token\" => @token } \r\n\t\tdocxml=nessus_request('policy/list', post)\r\n\t\tlist = Array.new\r\n\t\tdocxml.root.elements['contents'].elements['policies'].each_element('//policy') {|policy|\r\n\t\t\t\tlist.push policy.elements['policyName'].text\r\n\t\t}\r\n\t\treturn list\r\n\tend",
"def names\n map(&:name)\n end",
"def names()\n names = []\n names.push \"q-\"\n return names\n end",
"def coeffs\n assign_names(@coeffs)\n end",
"def names()\n\t\tnames = []\n\t\tnames.push \"help\"\n\t\treturn names\n\tend",
"def makena_classes_u_p_sym\n makena_classes_u.map{|a| a.underscore.pluralize.to_sym}\n end",
"def as_names\n __getobj__.map { |i| i.name }\n end",
"def policy_list_names\n\t\t\tpost= { \"token\" => @token }\n\t\t\tdocxml = nil\n\t\t\tdocxml=nessus_request('policy/list', post)\n\t\t\tif docxml.nil?\n\t\t\t\treturn\n\t\t\tend\n\t\t\tlist = Array.new\n\t\t\tdocxml.root.elements['contents'].elements['policies'].each_element('//policy') {|policy|\n\t\t\t\tlist.push policy.elements['policyName'].text\n\t\t\t}\n\t\t\treturn list\n\t\tend",
"def names\n [name]\n end",
"def all_name_strings\n names.collect { |a| a.name }\n end",
"def get_word_collection\n\t\tword_collection = GpInSignal.get_input_signals_names.map {|n| n.name }\n\t\tword_collection += GpOutSignal.get_output_signals_names.map {|n| n.name }\n\t\tword_collection += GpInput.get_input_names(@system).map {|n| n.name }\n\t\tword_collection += GpOutput.get_output_names(@system).map {|n| n.name }\n word_collection << \"Crosspoint\"\n\t\treturn word_collection\n\tend",
"def name\n [@n.to_s + character.to_s, symmetry].reject{|p| p == \"\"}.join(\"_\")\n end",
"def list_names\n @lib.list_names\n end",
"def names\n Array(@name)\n end",
"def curve_name(direction)\n :\"#{carrier}_#{direction}_curve\"\n end",
"def all_names; end",
"def all_names; end",
"def corporate_names\n @mods_ng_xml.corporate_name.map { |n| n.display_value }\n end",
"def lifter_names_gym\n lifters_gym.map do |lifter|\n lifter.name\n end\n end",
"def curve_name(direction)\n :\"#{@carrier}_#{direction}_curve\"\n end",
"def list_known_names\n end",
"def model_names\n result = []\n ole_obj.Models.each do |el|\n result << el.name\n end\n result\n end",
"def lifter_names\n gym_lifters.map(&:name)\n end",
"def lifter_names\n lifters.map{|lifter|\n lifter.name\n }\n end",
"def names\n fs = []\n %w( COARSE_GRAIN_BUFFER FINE_GRAIN_BUFFER FINE_GRAIN_SYSTEM ATOMICS ).each { |f|\n fs.push(f) if self.include?( self.class.const_get(f) )\n }\n return fs\n end",
"def list_name_alpha\n return list_name(true)\n end",
"def defined_names\n @lhs_names\n end",
"def names\n fs = []\n %w( DENORM INF_NAN ROUND_TO_NEAREST ROUND_TO_ZERO ROUND_TO_INF FMA SOFT_FLOAT CORRECTLY_ROUNDED_DIVIDE_SQRT ).each { |f|\n fs.push(f) if self.include?( self.class.const_get(f) )\n }\n return fs\n end",
"def lifter_names\n lifters.map {|lifter| lifter.name}\n end",
"def names\n $LEDGER.keys\n end",
"def names\n collect { |n, v|\n n\n }\n end",
"def names\n\n get_list['list'].collect { |re, pa| re }\n end",
"def names\n collect { |a| a.name }\n end",
"def names\n @names ||= []\n end",
"def name_significance #adding an instance method\n parts = self.split( '-' )\n syllables = @@syllables.dup\n signif = parts.collect do |p|\n syllables.shift[p]\n end\n signif.join( ' ' )\n end",
"def all_names\n @__names__\n end",
"def lifter_names\n # binding.pry\n lifters.map { |lifter| lifter.name }\n end",
"def names\n @names ||= [@name]\n end",
"def names\n @nodes.map(&:name)\n end",
"def sample_names\n material.sample.name\n end",
"def lifters_names\n lifters.map {|memeber| member.name}\n end",
"def instruments_names\n instruments_s = \"\"\n\n instruments.each do |instrument|\n instruments_s += instrument.name + \", \"\n end\n\n return instruments_s.first(instruments_s.length-2)\n end",
"def all_names\n ret = []\n ret << @subject.CN unless @subject.CN.nil?\n ret.concat(self.san.names.map { |n| n.value }) unless self.san.nil?\n\n ret.sort.uniq\n end",
"def names\n platforms.map { |m| m.realname }\n end",
"def sw_subject_names(sep = ', ')\n mods_ng_xml.subject.name_el\n .select { |n_el| n_el.namePart }\n .map { |name_el_w_np| name_el_w_np.namePart.map(&:text).reject(&:empty?) }\n .reject(&:empty?)\n .map { |parts| parts.join(sep).strip }\n end",
"def names_to_switch_names(names = [])\n @switches.map do |_, o|\n if names.include? o.name\n o.respond_to?(:switch_name) ? o.switch_name : o.human_name\n else\n nil\n end\n end.compact\n end",
"def model_name_strings\n model_names.map(&:to_s)\n end",
"def obj_names(ol)\n ol.map do |o|\n case o\n when Hash\n (o[:name]) ? o[:name] : o['name']\n else\n (o.respond_to?(:name)) ? o.name : nil\n end\n end\n end",
"def secondary_instrument_names\n #instruments.map{|i|i.display_name}.join(\"~\")\n \"\"\n end",
"def lifters_name \n lifters.map do |lifter|\n lifter.name\n end\n end",
"def notation(name); end",
"def coin_names_arrays\n coins.map.with_index do |coin, index|\n \"#{index + 1} #{coin.name}\"\n end.each_slice(coins.size / 6)\n end",
"def extensions\n _, *segments = name.downcase.split(\".\", -1)\n\n segments.map.with_index do |segment, index|\n \".\" + segments[index..-1].join(\".\")\n end\n end",
"def names\n fs = []\n %w( READ_WRITE WRITE_ONLY READ_ONLY SVM_FINE_GRAIN_BUFFER SVM_ATOMICS ).each { |f|\n fs.push(f) if self.include?( self.class.const_get(f) )\n }\n return fs\n end",
"def names\n @list.keys\n end",
"def localized_names\n @localized_names ||= []\n end",
"def names\n planet_names = []\n @planets.each do |planet|\n planet_names << planet.name\n end\n return planet_names\n end",
"def names\n fs = []\n %w( DEFAULT CPU GPU ACCELERATOR CUSTOM ALL ).each { |f|\n fs.push(f) if self.include?( self.class.const_get(f) )\n }\n return fs\n end",
"def names\n fs = []\n %w( NONE CONST RESTRICT VOLATILE PIPE ).each { |f|\n fs.push(f) if self.include?( self.class.const_get(f) )\n }\n return fs\n end",
"def name\n Array.new.tap do |s|\n if @saturation == 0 && @lightness == 0\n s << \"Black\"\n elsif @saturation == 0 && @lightness == 100\n s << \"White\"\n elsif @saturation <= 15 && @saturation > 0\n s << \"Light\"\n elsif @lightness < 40 && @saturation > 0\n s << \"Dark\"\n end\n \n if @saturation > 0\n s << case @hue\n when 0..8, 347..360 then 'Red'\n when 9..42 then 'Orange'\n when 43..61 then 'Yellow'\n when 62..158 then 'Green'\n when 159..264 then 'Blue'\n when 265..285 then 'Purple'\n when 286..346 then 'Pink'\n end\n else\n s << \"Grey\"\n end\n end.join(' ')\n end",
"def names\n self.name.split(' ')\n end",
"def get_names\n @names\n end",
"def names\n iterator = @form_fields.keySet.iterator\n set = []\n set << iterator.next.toString.to_sym while iterator.hasNext\n set\n end",
"def getPovertyLikelihoodChartObjName\r\n\t\t\treturn \"mfiforce__Poverty_Likelihood_Chart__c\"\r\n\t\tend",
"def inflect_names(name) #:nodoc:\n camel = name.camelize\n under = camel.underscore\n plural = under.pluralize\n [camel, under, plural]\n end",
"def names_to_code(names)\n str = \"\"\n names.each do |name|\n code = ATTRIBUTES[name]\n if code\n str << \"\\e[#{code}m\"\n end\n end\n str\n end",
"def names\n @metrics.keys.dup.freeze\n end",
"def hyrax_group_names\n groups\n end",
"def element_names\n @element_names ||= { }\n end",
"def list_name(alpha = false)\n out = name(alpha)\n if out.blank?\n out = computing_id.to_s\n else\n if not computing_id.blank?\n out += ' (' + computing_id + ')'\n end\n end\n return out\n end",
"def name\n name_parts.compact.join(' ')\n end",
"def expressed_taxon_names\n self.expression_matrix_files\n .map {|f| f.taxon.try(:scientific_name) }\n .uniq\n end",
"def glyph_names(uri)\n images = files(uri).sort\n\n if images.empty?\n raise Compass::SpriteException, %Q{No glyph images were found matching \"#{uri}\" in the images path. Your current images path is: #{folder}}\n end\n\n images.map { |f| File.basename(f)[0..-5] }\n end",
"def masculine_name; end",
"def question_names\n self.catalogs.reduce([]) do |names, catalog|\n questions = \"#{catalog.capitalize}Catalog\".constantize.const_get(\"QUESTIONS\")\n namespaced_questions = questions.map{|question| \"#{catalog}_#{question}\".to_sym }\n\n names + namespaced_questions\n end\n end",
"def names\n map(&:name).map(&:downcase).uniq\n end",
"def used_names; end",
"def create_array_valid_parking_names\n\t\tvalid_parking_names = [\n\t\t\t'01 MANUEL AZAÑA',\n\t\t\t'02 C C BUENAVISTA',\n\t\t\t'03 ALHÓNDIGA CENTRO CIVICO',\n\t\t\t'04 ESTACIÓN GETAFE CENTRAL',\n\t\t\t'05 PLAZA CARRETAS',\n\t\t\t'06 PLAZA DE ESPAÑA',\n\t\t\t'07 C\\MADRID - DE LA CIERVA',\n\t\t\t'08 C C JUAN DE LA CIERVA',\n\t\t\t'09 RESID. DE ESTUDIANTES',\n\t\t\t'10 FUENTE DE GOYA',\n\t\t\t'11 TRECE ROSAS',\n\t\t\t'12 PARQUE AVIOCAR',\n\t\t\t'13 POLIDEP. ALHÓNDIGA',\n\t\t\t'14 PL. DE LA MAGDALENA'\n\t\t]\n\n\t\treturn valid_parking_names\n\tend",
"def kesha_maker(array)\n\tnew_array = []\n\tarray.each do|name|\n\t\tname[2] = \"$\"\n\t\tnew_array << name\n\tend\n\tnew_array\nend",
"def list(names)\n if names.size == 0 ; return ''\n elsif names.size == 1 ; return \"#{names[0][:name]}\"\n else ; first_elements = names[0..-2].map {|element| element[:name]}\n return \"#{first_elements.join(\", \")} & #{names[-1][:name]}\"\n end\nend",
"def parse_ruleset_name(name)\n if Hash === name\n raise ArgumentError if name.size > 1 \n list = [name.values].flatten.map{ |b| b.to_sym }\n name = name.keys.first\n else\n list = []\n end\n return name.to_sym, list\n end",
"def parse_ruleset_name(name)\n if Hash === name\n raise ArgumentError if name.size > 1 \n list = [name.values].flatten.map{ |b| b.to_sym }\n name = name.keys.first\n else\n list = []\n end\n return name.to_sym, list\n end",
"def parts\n name.split(\" \")\n end",
"def display_names\n collect { |a| a.display_name }\n end"
] |
[
"0.55047166",
"0.5396108",
"0.5383436",
"0.53287905",
"0.53287905",
"0.53287905",
"0.53287905",
"0.53287905",
"0.53287905",
"0.53287905",
"0.5303541",
"0.52750933",
"0.5259933",
"0.52515334",
"0.52482504",
"0.52275157",
"0.5216438",
"0.5197078",
"0.51948726",
"0.51739776",
"0.516128",
"0.51530284",
"0.51399857",
"0.5115973",
"0.510606",
"0.51037776",
"0.5080274",
"0.50677204",
"0.5062654",
"0.5058567",
"0.50459516",
"0.5041613",
"0.5041613",
"0.50171703",
"0.50001967",
"0.4984397",
"0.49796927",
"0.49541664",
"0.49537304",
"0.49435666",
"0.49162894",
"0.4894949",
"0.48939982",
"0.48917064",
"0.48907533",
"0.48889256",
"0.48783085",
"0.48713154",
"0.48546615",
"0.48469517",
"0.48352557",
"0.4821388",
"0.48168096",
"0.4810051",
"0.48023447",
"0.4791881",
"0.47770187",
"0.47699007",
"0.47639441",
"0.47240266",
"0.47212762",
"0.47207645",
"0.4695231",
"0.46879178",
"0.46785057",
"0.4676337",
"0.46747977",
"0.46704727",
"0.46647257",
"0.46598166",
"0.46493495",
"0.46362588",
"0.46322873",
"0.46297202",
"0.4627891",
"0.46249455",
"0.462373",
"0.46170008",
"0.4613305",
"0.46083042",
"0.460355",
"0.4579464",
"0.45791012",
"0.4569438",
"0.45681575",
"0.4567766",
"0.4558336",
"0.45536587",
"0.4551618",
"0.45496625",
"0.4541711",
"0.45407927",
"0.45395777",
"0.4528928",
"0.452778",
"0.45227775",
"0.45217654",
"0.45217654",
"0.4520718",
"0.4517963"
] |
0.7154525
|
0
|
Returns an object representing the curve selected Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.curve('ILD')
|
def curve(curve_name)
self.curves[curve_name]
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def curve\n end",
"def curve\n end",
"def add_curve(*args)\n end",
"def curve(base)\n if base.respond_to?(:to_curve) && base.length == Fever::FRAMES\n return base.to_curve\n end\n\n case base\n when Numeric then curve_from_numeric(base)\n when Enumerable then curve_from_enum(base)\n else raise(ArgumentError, \"cannot create a curve from #{ base.inspect }\")\n end\n end",
"def curve_names\n self.curves.keys\n end",
"def load_curve\n curve = Curve.new([], Merit::POINTS)\n\n Merit::POINTS.times do |point|\n if cheaper_locally?(point)\n curve.set(point, [\n available_capacity(point),\n foreign_demand(point),\n @capacity.get(point)\n ].min)\n else\n curve.set(point, 0.0)\n end\n end\n\n curve\n end",
"def price_curve\n load_curve('price.csv')\n end",
"def explode_curve\n end",
"def explode_curve\n end",
"def load_curve\n if always_on?\n max_load_curve\n else\n @load_curve\n end\n end",
"def price_curve\n @price_curve ||= PriceCurve.new(self, fallback_price)\n end",
"def set_cn_curve\n @cn_curve = CnCurve.find(params[:id])\n end",
"def curve_for_storage\n sanitized_curve\n end",
"def create\n @curve = Curve.new(params[:curve])\n\n respond_to do |format|\n if @curve.save\n format.html { redirect_to @curve, notice: 'Curve was successfully created.' }\n format.json { render json: @curve, status: :created, location: @curve }\n else\n format.html { render action: \"new\" }\n format.json { render json: @curve.errors, status: :unprocessable_entity }\n end\n end\n end",
"def demand_curve\n load_curve('demand.csv')\n end",
"def ramping_curve\n Curve.new(load_curve.each_cons(2).map { |a, b| (b - a).abs })\n end",
"def curve(name, node)\n carrier, direction =\n Qernel::Causality::SelfDemandProfile\n .decode_name(name)\n .values_at(:carrier, :direction)\n\n case carrier\n when :electricity\n electricity_merit_self_curve(node, carrier, direction)\n when :steam_hot_water\n heat_network_merit_self_curve(node, carrier, direction)\n when :useable_heat, :heat\n fever_self_curve(node, carrier, direction)\n else\n raise %(Unsupported curve: \"self: #{name}\" on #{node.key})\n end\n end",
"def curve_name\n if self.ec?\n @spki.public_key.group.curve_name\n else\n raise R509::R509Error, 'Curve name is only available with EC SPKIs'\n end\n end",
"def curve(x0, y0, x1, y1, x2, y2, x3, y3)\n cur_page.curve(x0, y0, x1, y1, x2, y2, x3, y3)\n end",
"def initialize(curve)\n @curve = curve\n @errors = []\n @error_keys = []\n end",
"def self_curve(name, node)\n @self_curves ||= SelfCurves.new(@graph.plugin(:time_resolve), @context)\n @self_curves.curve(name, node)\n end",
"def load_curves\n LoadCurvePresenter.present(self).transpose\n end",
"def curve_name(direction)\n :\"#{carrier}_#{direction}_curve\"\n end",
"def curve_name(direction)\n :\"#{@carrier}_#{direction}_curve\"\n end",
"def initialize(curve_expression)\n raise InvalidCurveError, \"A curve expression should have :c as it's first symbol\" unless curve_expression[0] == :c\n raise InvalidCurveError, \"Curve expression contained no values\" unless curve_expression[2]\n \n # Nuke7 sometimes produces curves where the command is a string literal \n # within quotes, and it contains a trailing space\n cmd = curve_expression[1].to_s.strip\n raise InvalidCurveError, \"Curve expression should start with a 'curve' command\" unless cmd =~ /^curve/\n \n # Compute the curve increment or decrement. It looks like a modifier:\n # \"curve+5\" means we have to add 5 to every value on the curve\n xformer = lambda { |v| v} # Identity\n if cmd =~ /^(curve)([+-])([\\d\\.]+)$/\n operator = $2[0..1] # Ensure only one character gets through\n modifier = $3.to_f\n xformer = lambda{|v| v.send(operator, modifier) }\n end\n \n expand_curve(curve_expression, &xformer)\n end",
"def consumption_curve\n consumption = @adapters\n .select { |a| a.config.type == :consumer && a.config.subtype != :pseudo }\n .map { |c| c.participant.load_curve }\n\n Merit::CurveTools.add_curves(consumption) || EMPTY_CURVE\n end",
"def curve(name, node)\n name = name.to_s\n\n # Fever and self curves come from Fever or another Merit instance and\n # are already rotated.\n if prefix?(name, 'fever-electricity-demand')\n fever_demand_curve(name[25..-1].strip.to_sym)\n elsif prefix?(name, 'self')\n self_curve(name[5..-1].strip.to_sym, node)\n else\n super\n end\n end",
"def define_curve_adder(num_curves)\n params = Array.new(num_curves) { |i| \"c#{i}\" }\n param_list = params.join(', ')\n name = :\"add_curves_#{num_curves}\"\n\n # rubocop:disable Style/DocumentDynamicEvalDefinition\n instance_eval(<<-RUBY, __FILE__, __LINE__ + 1)\n def #{name}(#{param_list})\n length = curves_length(#{param_list})\n\n ::Merit::Curve.new(Array.new(length) do |index|\n #{params.map { |p| \"(#{p}[index] || 0.0)\" }.join(' + ')}\n end)\n end\n\n private_class_method name\n RUBY\n # rubocop:enable Style/DocumentDynamicEvalDefinition\n\n name\n end",
"def TIME_CURVE(curve_key, attribute)\n dataset.time_curve(curve_key).get(@dataset.analysis_year, attribute)\n end",
"def show\n @curve = Curve.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @curve }\n end\n end",
"def linetool\n Sketchup.active_model.select_tool LineTool.new\nend",
"def spare_load_curve\n max_load_curve - load_curve\n end",
"def curve(x1, y1, x2, y2, x3, y3)\n [x1.value, y1.value, x2.value, y2.value, x3.value, y3.value]\n end",
"def new\n @curve = Curve.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @curve }\n end\n end",
"def create\n @cn_curve = CnCurve.new(cn_curve_params)\n\n respond_to do |format|\n if @cn_curve.save\n format.html { redirect_to @cn_curve, notice: 'Cn curve was successfully created.' }\n format.json { render json: @cn_curve, status: :created }\n else\n format.html { render action: 'new' }\n format.json { render json: @cn_curve.errors, status: :unprocessable_entity }\n end\n end\n end",
"def sanitized_curve\n valid? ? @curve : nil\n end",
"def time_curve(key)\n (@time_curves ||= {})[key.to_sym] ||=\n CSVDocument.new(\n dataset_dir.join(\"time_curves/#{ key }_time_curve.csv\"))\n end",
"def bezier_curve(params = {})\n params[:name] ||= @pictureName.gsub('.png', 'Bezier.png')\n params[:save] ||= @picturePath\n \n display_picture\n \n points = parse_points\n \n if points.nil? \n puts \"Unable to draw: no control points generated.\"\n return false\n else\n bez = dup\n bez.picture = bez.picture.bezier_curve(points)\n bez.pictureName, bez.picturePath = params[:name], params[:save]\n return bez\n end\n end",
"def demand_curve\n @demand_curve ||= CurveTools.add_curves(\n participants.users.reject(&:provides_price?).map(&:load_curve)\n )\n end",
"def quadratic_curve(x1, y1, x2, y2)\n [x1.value, y1.value, x2.value, y2.value]\n end",
"def create_handler(curve_name, io)\n CurveHandler::AttachService.new(\n config_for(curve_name),\n io,\n scenario,\n metadata_parameters\n )\n end",
"def inject_curve!(direction = nil, full_name: nil)\n if direction.nil? && full_name.nil?\n raise 'No curve name given to inject_curve!'\n end\n\n name = full_name || @context.curve_name(direction)\n\n target_api.dataset_lazy_set(name) do\n @context.curves.derotate(yield.to_a)\n end\n end",
"def max_load_curve\n @max_load_curve ||= Curve.new(\n if @load_profile\n @load_profile.values.map { |v| v * max_production }\n else\n Array.new(Merit::POINTS, available_output_capacity)\n end\n )\n end",
"def curve_points(points)\n cur_page.curve_points(points)\n end",
"def CreateBsplineCurveElement2(arg0, arg1)\n ret = _invoke(1610744122, [arg0, arg1], [VT_BYREF | VT_DISPATCH, VT_BYREF | VT_DISPATCH])\n @lastargs = WIN32OLE::ARGV\n ret\n end",
"def production_curve\n production = @adapters\n .select { |a| a.config.type == :producer && PRODUCTION_TYPES.include?(a.config.subtype) }\n .map { |c| c.participant.load_curve }\n\n (Merit::CurveTools.add_curves(production) || EMPTY_CURVE).map(&:-@)\n end",
"def fever_demand_curve(name)\n @household_heat.curve(name)\n end",
"def learning_curve_strategy\n @learning_curve = []\n current_week_data = strategy_stats (Time.now.all_week())\n prev_week_data = strategy_stats ((Time.now-1.week).all_week())\n prev_month_data = strategy_stats ((Time.now-1.month).all_month())\n current_month_data = strategy_stats (Time.now.all_month())\n @learning_curve << (average(current_week_data) - average(prev_week_data)).round(2)\n @learning_curve << (average(current_month_data) - average(prev_month_data)).round(2)\n end",
"def CreateBsplineCurveElement1(arg0, arg1)\n ret = _invoke(1610744121, [arg0, arg1], [VT_BYREF | VT_DISPATCH, VT_BYREF | VT_DISPATCH])\n @lastargs = WIN32OLE::ARGV\n ret\n end",
"def test_portsmouth_recurve_scoring # Recurve\n\n portsmouth_std_definition = [\n {'range_in_meters' => 18.288, 'total_shots' => 60, 'target_diameter_cm' => 60, 'scoring_scheme' => 'METRIC'}\n ]\n\n # 599 sin tables = 5\n [ [308, 71], [501, 47], [587, 18], [599, 4] ].each do | score, expected_hc |\n result = AgbHandicap.calculate(score, portsmouth_std_definition)\n assert_equal expected_hc, result, \"Portsmouth #{score} score should be #{expected_hc}\"\n end\n end",
"def calc_spread_to_curve(csv)\n file = prep_spread_data(csv)\n\n # print title\n print_spread('bond,spread_to_curve')\n\n gov_lower = nil #hold government lower bound term\n corp_tmp = []\n file.each do |data|\n if data[1] == \"corporate\"\n corp_tmp.push data\n else # government entry\n corp_tmp.each do |corp_data|\n y = corp_data[3]\n #calculate linear interpolation yield = a*term+b\n a = ((data[3]-gov_lower[3])/(data[2]-gov_lower[2])).abs\n b = data[3] - a*data[2]\n y2 = a*corp_data[2] + b\n print_spread(corp_data[0], (y-y2).abs)\n end\n corp_tmp = []\n gov_lower = data #update lower bound\n end\n end\nend",
"def update\n @curve = Curve.find(params[:id])\n\n respond_to do |format|\n if @curve.update_attributes(params[:curve])\n format.html { redirect_to @curve, notice: 'Curve was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @curve.errors, status: :unprocessable_entity }\n end\n end\n end",
"def behavior\n @behavior ||= (unit == 'curve' ? CurveBehavior : NullBehavior)\n end",
"def inject_curve!(direction = nil, full_name: nil)\n if direction.nil? && full_name.nil?\n raise 'No curve name given to inject_curve!'\n end\n\n name = full_name || :\"heat_#{direction}_curve\"\n\n @node.dataset_lazy_set(name.to_sym) do\n @context.curves.derotate(yield.to_a)\n end\n end",
"def CreateCurveElement1(arg0, arg1)\n ret = _invoke(1610743978, [arg0, arg1], [VT_BYREF | VT_DISPATCH, VT_BYREF | VT_ARRAY | VT_DISPATCH])\n @lastargs = WIN32OLE::ARGV\n ret\n end",
"def revenue_curve\n @revenue_curve ||= load_curve * order.price_curve\n end",
"def to_simple_path(*_)\n # convert bezier curves and spiro splines\n path = to_cubic_path.nodes\n\n nodes = []\n path.each_index do |i|\n case path[i].type\n when :node\n if path[i - 1].type == :cubic\n curve = path[i - 3..i].map(&:at)\n nodes += VectorSalad::Interpolate.new.casteljau(curve)\n else\n nodes << path[i]\n end\n when :cubic\n else\n fail \"Only :node and :cubic nodes in a path can be converted\n to a simple path, was #{path[i].type}.\"\n end\n end\n Path.new(*nodes, closed: @closed, **@options)\n end",
"def arc_curve=(arc_curve)\n end",
"def gfp_standard_curve(coordinates)\n # Calculating Std Curve for GFP\n num_of_pts = 0\n a = 0\n x_sum = 0\n y_sum = 0\n x_sq_sum = 0\n x_arr = []\n y_arr = []\n coordinates.each do |x, y|\n if x < 25 # Above 25uM is out of linear range of our instrument\n a += (x * y)\n x_sum += x\n x_sq_sum += (x**2)\n y_sum += y\n x_arr.push(x)\n y_arr.push(y)\n num_of_pts += 1\n end\n end\n a *= num_of_pts\n b = x_sum * y_sum\n c = num_of_pts * x_sq_sum\n d = x_sum**2\n slope = (a - b)/(c - d)\n f = slope * (x_sum)\n yint = (y_sum - f)/num_of_pts\n # show{note \"y = #{(slope).round(2)}x + #{(yint).round(2)}\"}\n return (slope).round(3), (yint).round(3), x_arr, y_arr\n end",
"def curve_from_numeric(numeric)\n [numeric] * Fever::FRAMES\n end",
"def curve_from_enum(enum)\n length = enum.length\n\n if length == FRAMES\n return enum.respond_to?(:to_curve) ? enum.to_curve : enum.to_a.dup\n end\n\n if length > FRAMES\n raise(\n ArgumentError,\n \"Input curve has too many items (#{ enum.length }), \" \\\n \"must not exceed #{ Fever::FRAMES }\"\n )\n end\n\n enum.to_a + Array.new(FRAMES - enum.length, 0.0)\n end",
"def to_bezier_path\n path = to_path\n spiro = false\n flat_path = path.nodes.map do |n|\n spiro = true if spiro || [:g2, :g4, :left, :right].include?(n.type)\n [n.x, n.y, n.type]\n end\n if spiro\n flat_spline_path = Spiro.spiros_to_splines(flat_path, @closed)\n if flat_spline_path.nil?\n fail \"Spiro failed, try different coordinates or using G2 nodes.\"\n else\n path = Path.new(*flat_spline_path.map do |n|\n N.new(n[0], n[1], n[2])\n end, closed: @closed, **@options)\n end\n end\n path\n end",
"def open_curve(vertices)\n return if vertices.empty?\n vertices = vertices.dup\n origin = vertices.shift\n move_to(origin[:point])\n previous_handle2 = origin[:handle2]\n vertices.each do |vertex|\n curve_to(vertex[:point],\n :bounds => [previous_handle2 || vertex[:point],\n vertex[:handle1] || vertex[:point]])\n previous_handle2 = vertex[:handle2]\n end\n end",
"def curve(cp1x, cp1y, cp2x, cp2y, x1, y1, x2, y2)\n beginpath(x1, y1)\n CGContextAddCurveToPoint(@ctx, cp1x, cp1y, cp2x, cp2y, x2, y2)\n endpath\n end",
"def to_cubic_path\n path = to_bezier_path.nodes\n cubic_path = []\n quadratic_last = false\n path.each_index do |i|\n n = path[i]\n if quadratic_last\n n0 = path[i - 2]\n q = path[i - 1]\n\n # CP1 = QP0 + 2/3 * (QP1-QP0)\n # CP2 = QP2 + 2/3 * (QP1-QP2)\n third = 2 / 3.0\n cubic_path << N.c(\n n0.x + third * (q.x - n0.x),\n n0.y + third * (q.y - n0.y)\n )\n cubic_path << N.c(\n n.x + third * (q.x - n.x),\n n.y + third * (q.y - n.y)\n )\n cubic_path << n\n\n quadratic_last = false\n elsif n.type == :quadratic\n quadratic_last = true\n else\n cubic_path << n\n end\n end\n Path.new(*cubic_path, closed: @closed, **@options)\n end",
"def call(curve)\n if @reducer.arity == 2\n @reducer.call(curve, default_curve)\n else\n @reducer.call(curve)\n end\n end",
"def cn_curve_params\n params.require(:cn_curve).permit(:c_enr_1, :n_enr_1, :c_percent_1, :n_percent_1, :cn_ratio_1)\n end",
"def spline_fitting(sampled_points, interp_points)\n\t# this function takes a given set of discrete points and fit the curve of them using piece wise splines functions\t\n\t\nend",
"def load_at(point)\n @load_curve[point]\n end",
"def curtailment_curve(demand)\n return zeroed_profile if @curtailment.zero?\n\n useable_profile.map.with_index do |curtailed_factor, frame|\n uncurtailed = demand * @profile[frame]\n uncurtailed - (demand * curtailed_factor)\n end\n end",
"def availability_curve(from)\n return [from.clamp(0.0, 1.0)] * Merit::POINTS if from.is_a?(Numeric)\n\n unless from.length == Merit::POINTS\n raise(\n ArgumentError,\n \"availability curve must have #{Merit::POINTS} elements (got #{from.length})\"\n )\n end\n\n from.map { |value| value.clamp(0.0, 1.0) }\n end",
"def destroy\n @curve = Curve.find(params[:id])\n @curve.destroy\n\n respond_to do |format|\n format.html { redirect_to curves_url }\n format.json { head :no_content }\n end\n end",
"def item_characteristic_curve\n i=0\n out={}\n total={}\n @ds.each do |row|\n tot=@total[i]\n @ds.vectors.each do |f|\n out[f]||= {}\n total[f]||={}\n out[f][tot]||= 0\n total[f][tot]||=0\n out[f][tot]+= row[f]\n total[f][tot]+=1\n end\n i+=1\n end\n total.each do |f,var|\n var.each do |tot,v|\n out[f][tot]=out[f][tot].quo(total[f][tot])\n end\n end\n out\n end",
"def elec_demand_curve\n @elec_demand_curve ||= ElectricityDemandCurve.from_adapters(adapters)\n end",
"def getsfLma__LicenseObjName\r\n\t\t\treturn \"sfLma__License__c\"\r\n\t\tend",
"def closed_curve(vertices)\n return if vertices.empty?\n vertices = vertices.dup\n origin = vertices.shift\n move_to(origin[:point])\n previous_handle2 = origin[:handle2]\n vertices.each do |vertex|\n curve_to(vertex[:point],\n :bounds => [previous_handle2 || vertex[:point],\n vertex[:handle1] || vertex[:point]])\n previous_handle2 = vertex[:handle2]\n end\n curve_to(origin[:point],\n :bounds => [previous_handle2 || origin[:point],\n origin[:handle1] || origin[:point]])\n end",
"def cross_phase other\n complex2 other, :cross_phase\n end",
"def add_quadraticpath(controlPoint1: { :x => 0.0, :y => 0.0 }, \n endPoint: { :x => 10.0, :y => 20.0 })\n pathElement = { :elementtype => \"pathquadraticcurve\",\n :controlpoint1 => controlPoint1,\n :endpoint => endPoint }\n @pathArray.push(pathElement)\n @pathArray\n end",
"def demand_curve\n @demand_curve ||= begin\n unlimited_carrier_curve.map do |value|\n value < @carrier_capacity ? value : @carrier_capacity\n end\n end\n end",
"def write_channel(interpolator, to_io, from_frame_i, to_frame_i)\n @c = Framecurve::Curve.new\n super\n Framecurve::Serializer.new.serialize(to_io, @c)\n end",
"def ec_from_params(curve, pub_key, priv_key)\n # Old versions of jruby-openssl don't include an EC class (version 0.9.16).\n ec_class = (::OpenSSL::PKey::EC rescue raise ArgumentError, \"Unsupported algorithm: #{ppk.algorithm}\")\n\n ec_class.new(curve).tap do |pkey|\n group = pkey.group || ::OpenSSL::PKey::EC::Group.new(curve)\n pkey.public_key = ::OpenSSL::PKey::EC::Point.new(group, pub_key)\n pkey.private_key = priv_key\n end\n end",
"def new\n @lyric = Lyric.new\n end",
"def new\n @lyric = Lyric.new\n end",
"def test_is_polygon_with_curve\n m = Sketchup.active_model\n ents = m.entities\n\n # Create a curve\n pts = []\n pts.push [1, 4, 0]\n pts.push [3, 3, 0]\n pts.push [2, 3, 0]\n pts.push [0, 4, 0]\n pts.push [3, 2, 0]\n pts.push [3, -2, 0]\n pts.push [3, -3, 0]\n pts.push [2, -4, 0]\n pts.push [1, -4, 0]\n ents.add_curve pts\n\n # Check curve edges\n m.entities.each do |e|\n if e.is_a? Sketchup::Edge and e.curve.respond_to? 'is_polygon?'\n assert_equal(false, e.curve.is_polygon?,\n 'Curve of curve edge should not be polygon.')\n end\n end\n end",
"def get_line(y)\n \n x = Array(1..y.size)\n # generate the linear regressions required to produce the linear equation\n ts = LineFit.new \n # this method does the work\n ts.setData(x,y)\n #index 0 = y intercept, index 1 = slope\n line_array = ts.coefficients()\n\nend",
"def learning_curve factor\n @learning_curve = []\n current_week_data = current_user.reports.where(exam_date:(Time.now.all_week())).map {|x| x.send(:\"#{factor}\")}\n prev_week_data = current_user.reports.where(exam_date:((Time.now-1.week).all_week())).map {|x| x.send(:\"#{factor}\")}\n @learning_curve << (average(current_week_data) - average(prev_week_data)).round(2)\n current_month_data = current_user.reports.where(exam_date:(Time.now.all_month())).map {|x| x.send(:\"#{factor}\")}\n prev_month_data = current_user.reports.where(exam_date:((Time.now-1.month).all_month())).map {|x| x.send(:\"#{factor}\")}\n @learning_curve << (average(current_month_data) - average(prev_month_data)).round(2)\n @learning_curve = [0,0] if @learning_curve.empty?\n end",
"def time_curves\n Pathname.glob(dataset_dir.join('time_curves/*.csv')).each do |csv_path|\n time_curve(csv_path.basename('_time_curve.csv').to_s)\n end\n\n @time_curves ||= {}\n end",
"def bezier_curve(points, stroke_color = ChunkyPNG::Color::BLACK)\n points = ChunkyPNG::Vector(*points)\n case points.length\n when 0, 1 then return self\n when 2 then return line(points[0].x, points[0].y, points[1].x, points[1].y, stroke_color)\n end\n\n curve_points = []\n\n t = 0\n n = points.length - 1\n\n while t <= 100\n bicof = 0\n cur_p = ChunkyPNG::Point.new(0, 0)\n\n # Generate a float of t.\n t_f = t / 100.00\n\n cur_p.x += ((1 - t_f)**n) * points[0].x\n cur_p.y += ((1 - t_f)**n) * points[0].y\n\n for i in 1...points.length - 1\n bicof = binomial_coefficient(n, i)\n\n cur_p.x += (bicof * (1 - t_f)**(n - i)) * (t_f**i) * points[i].x\n cur_p.y += (bicof * (1 - t_f)**(n - i)) * (t_f**i) * points[i].y\n i += 1\n end\n\n cur_p.x += (t_f**n) * points[n].x\n cur_p.y += (t_f**n) * points[n].y\n\n curve_points << cur_p\n\n t += 1\n end\n\n curve_points.each_cons(2) do |p1, p2|\n line_xiaolin_wu(p1.x.round, p1.y.round, p2.x.round, p2.y.round, stroke_color)\n end\n\n self\n end",
"def remove_unused_curves(model)\n model.getCurves.each do |curve|\n if curve.directUseCount == 0\n model.removeObject(curve.handle)\n end\n end\n return model\n end",
"def ensure_valid_curve_name\n return if CurveHandler::Config.key?(params[:id])\n\n render(\n json: { errors: [\"No such custom curve: #{params[:id].inspect}\"] },\n status: 422\n )\n end",
"def unlimited_carrier_curve\n demand_profile * max_carrier_production\n end",
"def create_pathdrawelement(line_width: 16.0, stroke_color: nil)\n strokeColor = stroke_color unless stroke_color.nil?\n strokeColor = MIColor.make_rgbacolor(0.2, 0.2, 0.2) if stroke_color.nil?\n arcBox = MIShapes.make_rectangle(width: $theWidth, height: $theHeight)\n startX = $theWidth * 0.5 + $radius * Math.sin(-0.75 * Math::PI)\n startY = $theHeight * 0.5 + $radius * Math.cos(-0.75 * Math::PI)\n startPoint = MIShapes.make_point(startX, startY)\n arcBBox = MIShapes.make_rectangle(width: $theWidth, height: $theHeight)\n thePath = make_arcpath(inBox: arcBBox, radius: $radius)\n pathDrawElement = MIDrawElement.new(:strokepath)\n pathDrawElement.arrayofpathelements = thePath\n pathDrawElement.startpoint = startPoint\n pathDrawElement.linewidth = line_width\n pathDrawElement.linecap = :kCGLineCapRound\n pathDrawElement.strokecolor = strokeColor\n pathDrawElement\nend",
"def update\n respond_to do |format|\n if @cn_curve.update(cn_curve_params)\n format.html { redirect_to @cn_curve, notice: 'Cn curve was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @cn_curve.errors, status: :unprocessable_entity }\n end\n end\n end",
"def pricing_policy\n car.pricing_policy\n end",
"def qcurve(cpx, cpy, x1, y1, x2, y2)\n beginpath(x1, y1)\n CGContextAddQuadCurveToPoint(@ctx, cpx, cpy, x2, y2)\n endpath\n end",
"def basis\n return @basis\n end",
"def end_point\n raise Error::UnsupportedOperation, \"Method Curve#end_point not defined.\"\n end",
"def get_comp_selection\n @comp_current_throw = [\"rock\", \"paper\", \"scissors\"].sample\n end",
"def turn(curve_symbol)\n case curve_symbol\n when \"\\\\\"\n case @mov_dir\n when :up\n @mov_dir = :left\n when :right\n @mov_dir = :down\n when :down\n @mov_dir = :right\n when :left\n @mov_dir = :up\n end\n\n when \"\\/\"\n case @mov_dir\n when :up\n @mov_dir = :right\n when :right\n @mov_dir = :up\n when :down\n @mov_dir = :left\n when :left\n @mov_dir = :down \n end\n\n else\n puts 'ERROR: Wrong curve symbol used'\n exit -1\n end\n end",
"def interpolation\n # Just return the interpolation type for pre-2012 setups\n return (@interpolation || :constant) unless has_2012_tangents?\n \n return :constant if curve_order.to_s == \"constant\"\n return :hermite if curve_order.to_s == \"cubic\" && (curve_mode.to_s == \"hermite\" || curve_mode.to_s == \"natural\")\n return :bezier if curve_order.to_s == \"cubic\" && curve_mode.to_s == \"bezier\"\n return :linear if curve_order.to_s == \"linear\"\n \n raise \"Cannot determine interpolation for #{inspect}\"\n end"
] |
[
"0.66901845",
"0.66901845",
"0.6249164",
"0.61700153",
"0.6108652",
"0.61054754",
"0.6104347",
"0.59153837",
"0.59153837",
"0.58253616",
"0.5818646",
"0.5791126",
"0.56843776",
"0.5656987",
"0.5641351",
"0.56204563",
"0.55703455",
"0.55378777",
"0.5532485",
"0.5500147",
"0.5483606",
"0.5481234",
"0.5476084",
"0.54524463",
"0.54069656",
"0.54036725",
"0.53691256",
"0.5255009",
"0.52505714",
"0.5233687",
"0.51940876",
"0.5189966",
"0.5183856",
"0.515012",
"0.5119143",
"0.51058084",
"0.5104591",
"0.5091154",
"0.5083095",
"0.5075803",
"0.5069737",
"0.5058391",
"0.50512296",
"0.5028621",
"0.50101405",
"0.49934882",
"0.497671",
"0.49255627",
"0.49184713",
"0.4916095",
"0.4887085",
"0.4878628",
"0.4869642",
"0.48333666",
"0.48279434",
"0.4826618",
"0.48258203",
"0.48235536",
"0.4810568",
"0.4801457",
"0.48010927",
"0.47517905",
"0.46760088",
"0.4639106",
"0.46383977",
"0.463713",
"0.4610454",
"0.45570904",
"0.45272842",
"0.45260912",
"0.45082924",
"0.4506644",
"0.44888294",
"0.44694528",
"0.44563866",
"0.44531134",
"0.44455427",
"0.44171402",
"0.44146642",
"0.44121718",
"0.4410042",
"0.44076073",
"0.44076073",
"0.43961167",
"0.43867135",
"0.4380322",
"0.4369205",
"0.4367016",
"0.43616927",
"0.43199015",
"0.43105453",
"0.43058228",
"0.4303981",
"0.42917272",
"0.42903358",
"0.42895484",
"0.42677313",
"0.4266928",
"0.42668998",
"0.42490217"
] |
0.7155257
|
0
|
Return a list of mnemonics representing the curve names Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.well_name => "ANY ET AL OIL WELL 12"
|
def well_name
self.well_info.well_name
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def names\n @mplab_pin.names\n end",
"def name_significance #adding an instance method\n parts = self.split( '-' )\n syllables = @@syllables.dup\n signif = parts.collect do |p|\n syllables.shift[p]\n end\n signif.join( ' ' )\n end",
"def lifter_names_gym\n lifters_gym.map do |lifter|\n lifter.name\n end\n end",
"def lifter_names\n gym_lifters.map(&:name)\n end",
"def name\n [@n.to_s + character.to_s, symmetry].reject{|p| p == \"\"}.join(\"_\")\n end",
"def curve_names\n self.curves.keys\n end",
"def name\n return 'AedgSmallToMediumOfficeExteriorWallConstruction'\n end",
"def syllables\n @pronunciations.map { |p| p.first.num_syllables }.inject(:+)\n end",
"def list_name_alpha\n return list_name(true)\n end",
"def sample_names\n material.sample.name\n end",
"def masculine_name; end",
"def lifter_names\n lifters.map{|lifter|\n lifter.name\n }\n end",
"def standarized_coeffs\n assign_names(@coeffs_stan)\n end",
"def get_word_collection\n\t\tword_collection = GpInSignal.get_input_signals_names.map {|n| n.name }\n\t\tword_collection += GpOutSignal.get_output_signals_names.map {|n| n.name }\n\t\tword_collection += GpInput.get_input_names(@system).map {|n| n.name }\n\t\tword_collection += GpOutput.get_output_names(@system).map {|n| n.name }\n word_collection << \"Crosspoint\"\n\t\treturn word_collection\n\tend",
"def lifter_names\n lifters.map {|lifter| lifter.name}\n end",
"def lifter_names\n # binding.pry\n lifters.map { |lifter| lifter.name }\n end",
"def lifters_name \n lifters.map do |lifter|\n lifter.name\n end\n end",
"def name\n Array.new.tap do |s|\n if @saturation == 0 && @lightness == 0\n s << \"Black\"\n elsif @saturation == 0 && @lightness == 100\n s << \"White\"\n elsif @saturation <= 15 && @saturation > 0\n s << \"Light\"\n elsif @lightness < 40 && @saturation > 0\n s << \"Dark\"\n end\n \n if @saturation > 0\n s << case @hue\n when 0..8, 347..360 then 'Red'\n when 9..42 then 'Orange'\n when 43..61 then 'Yellow'\n when 62..158 then 'Green'\n when 159..264 then 'Blue'\n when 265..285 then 'Purple'\n when 286..346 then 'Pink'\n end\n else\n s << \"Grey\"\n end\n end.join(' ')\n end",
"def names\n [\n \"Charge de travail\" , #00\n \"Travail en groupe\" , #01\n \"Maths\" , #02\n \"Codage\" , #03\n \"Théorique\" , #04\n \"Technique\" , #05\n \"Satisfaction\" , #06\n \"Dur à valider\" , #07\n \"Fun\" , #08\n \"Pipo\" , #09\n \"Économie\" , #10\n \"fondamental\" , #11\n \"Difficile à suivre\" , #12\n \"Calcul\" , #13\n \"Professionalisant\" , #14\n \"Étendue du cours\" , #15\n \"Interactivité\" , #16\n \"Culture générale\" , #17\n ]\n end",
"def notation(name); end",
"def kesha_maker(array)\n\tnew_array = []\n\tarray.each do|name|\n\t\tname[2] = \"$\"\n\t\tnew_array << name\n\tend\n\tnew_array\nend",
"def list_name(alpha = false)\n out = name(alpha)\n if out.blank?\n out = computing_id.to_s\n else\n if not computing_id.blank?\n out += ' (' + computing_id + ')'\n end\n end\n return out\n end",
"def names\n case name\n when \"Road\"\n [nil, \"\", 'Circuit', \"Criterium\", \"Road\", \"Time Trial\", \"Singlespeed\", \"Tour\"]\n when \"Mountain Bike\"\n ['Downhill', 'Mountain Bike']\n else\n [name]\n end\n end",
"def yell_name\n\t\t@name.upcase + \"!\"\n\tend",
"def insured_name\n id, qual = eob.member_id_and_qualifier\n sub_name_ele = []\n sub_name_ele << 'NM1'\n sub_name_ele << 'IL'\n sub_name_ele << '1'\n sub_name_ele << eob.subscriber_last_name\n sub_name_ele << eob.subscriber_first_name\n sub_name_ele << eob.subscriber_middle_initial\n sub_name_ele << ''\n sub_name_ele << eob.subscriber_suffix\n sub_name_ele << qual\n sub_name_ele << id\n sub_name_ele = Output835.trim_segment(sub_name_ele)\n sub_name_ele.join(@element_seperator)\n end",
"def names; end",
"def names; end",
"def names; end",
"def names; end",
"def names; end",
"def names; end",
"def names; end",
"def parts\n name.split(\" \")\n end",
"def makena_classes_u_p_sym\n makena_classes_u.map{|a| a.underscore.pluralize.to_sym}\n end",
"def name\n return 'AedgSmallToMediumOfficeExteriorLighting'\n end",
"def name\n name_parts.compact.join(' ')\n end",
"def piece_name(p)\n if p.class.to_s == \"Symbol\"\n (p == :knight ? :night : p).to_s.downcase.split('').first\n else\n PIECES[p.downcase]\n end\n end",
"def name\n return \"Canadian Add Unitary and Apply Standard\"\n end",
"def kesha_maker(array)\n kesha_array = []\n array.each do |name|\n name[2] = \"$\"\n kesha_array << name\n end\n kesha_array\nend",
"def three_word_name; end",
"def names\n [name]\n end",
"def names\n self.name.split(' ')\n end",
"def corporate_names\n @mods_ng_xml.corporate_name.map { |n| n.display_value }\n end",
"def lnf\n a = name.split.rotate(-1)\n a[0] + ', ' + a.drop(1).join(' ')\n end",
"def getPovertyLikelihoodChartObjName\r\n\t\t\treturn \"mfiforce__Poverty_Likelihood_Chart__c\"\r\n\t\tend",
"def name\n \tself.marker_synonyms.collect{|ms| ms.name}.join(',')\n end",
"def names\n all.map { |item| item.name_sym }\n end",
"def name\n @example.description.scan(/\\((\\w+)\\)/).flatten.first\n rescue\n @example.description\n end",
"def names()\n names = []\n names.push \"q-\"\n return names\n end",
"def member_names(members)\n members.times do \n @band << @musicians.sample\n end\n\n puts \"Cool, that means the lineup will include:\"\n @band.each do |musician|\n puts \"#{musician}\"\n end\n\n end",
"def build_name\n \"#{manufacturer} #{weight} #{style} #{name}\"\n end",
"def medicinal_uses\n self.object.medicinal_uses.map{|mu| mu.name}.join(', ')\n end",
"def yell_name\r\n @name.upcase + \"!\"\r\n end",
"def secondary_instrument_names\n #instruments.map{|i|i.display_name}.join(\"~\")\n \"\"\n end",
"def name; termid;end",
"def yell_name\n @name.upcase + \"!\"\n end",
"def names()\n\t\tnames = []\n\t\tnames.push \"help\"\n\t\treturn names\n\tend",
"def wikified_name\n self.name.slice(0,1).capitalize + self.name.slice(1..-1).gsub(/ /, '_')\n end",
"def all_names; end",
"def all_names; end",
"def name_of_uvhw(well)\n plate, r, c = find_uvhw(well)\n return \"Well #{plate.id}(#{'ABCD'[r]}#{c+1})\"\n end",
"def live_name\n [\n transformed_part('product'),\n middle_name(standalone: false), # Will have word dividers on either side\n idx,\n maybe_upto,\n '-',\n parts['sku'] =~ /editorial/ && bang? ? 'square-' : nil,\n [name_base, ext_name].join\n ].compact.join\n end",
"def taxa_name_nwk(nwk_line)\n taxa = []\n nwk_line.tr(\"()\",\"\").split(\",\").each {|n| taxa << n.split(\":\")[0].tr(\"\\'\",\"\")}\n return taxa\nend",
"def two_word_name; end",
"def list_known_names\n end",
"def normalise_defined_name(name) # :nodoc:\n name.sub(/^_xlnm./, '').downcase\n end",
"def names\n map(&:name)\n end",
"def smiles\n to_s(:smi)\n end",
"def lifters_names\n lifters.map {|memeber| member.name}\n end",
"def names\n\n get_list['list'].collect { |re, pa| re }\n end",
"def names\n map(&:names).flatten\n end",
"def mls_information\n self.dig_for_array(\"mlsInformation\")\n end",
"def names\n platforms.map { |m| m.realname }\n end",
"def wells\n plates.collect(&:wells).flatten\n end",
"def modeler_description\n return 'Thermal zones will be named after the spac with a prefix added'\n end",
"def names\n $LEDGER.keys\n end",
"def drink_classifcation(name)\n size = Sizes.select{|s| name.match(s) }.first\n milk = Milks.select{|m| name.match(m) }.first\n [name, size, milk]\nend",
"def mk_intro\n [\"Kære \", \"Hej \", \"Goddag, \"].sample + @name\n end",
"def modeler_description\n return \"Calculates and assigns material layer properties of wood stud constructions for 1) above-grade walls between finished space and outside, and 2) above-grade walls between attics under insulated roofs and outside. If the walls have an existing construction, the layers (other than exterior finish, wall sheathing, and wall mass) are replaced. This measure is intended to be used in conjunction with Exterior Finish, Wall Sheathing, and Exterior Wall Mass measures.\"\n end",
"def modeler_description\n return \"Calculates and assigns material layer properties of wood stud constructions for 1) above-grade walls between finished space and outside, and 2) above-grade walls between attics under insulated roofs and outside. If the walls have an existing construction, the layers (other than exterior finish, wall sheathing, and wall mass) are replaced. This measure is intended to be used in conjunction with Exterior Finish, Wall Sheathing, and Exterior Wall Mass measures.\"\n end",
"def mexican_wave_x(str)\n wave = []\n chars = str.chars\n chars.each_with_index do |c, i|\n next if c =~ /\\s/\n wave << str[0...i] + c.upcase + str[i+1..-1]\n end\n wave\nend",
"def feminine_name; end",
"def one_word_names(list)\n own = list.select do |c|\n c[:name].include?(\" \") == false\n end\n return own\nend",
"def names\n map(&:name)\n end",
"def get_newspaper_sym\n \"WH\"\n end",
"def labels_from_animal_list(animal_list)\n formated_animal_list = Array.new\n animal_list.each do |animal_name|\n humanized_animal_name = ActiveSupport::Inflector.humanize( ActiveSupport::Inflector.camelize(animal_name).underscore).titleize\n #we want the species first so tokenize the string and invert a bit\n if humanized_animal_name.include?(\" \")\n words = humanized_animal_name.split(\" \")\n # take last word as species name so push in front of the rest\n humanized_animal_name = words.last + \", \" + words[0 .. words.length-2].join(\" \")\n end \n # note the heredoc string is whitespace aware\n formated_animal_list << <<-label\n #{animal_name}:\n label: '#{humanized_animal_name}'\n description: '''\n Describe #{humanized_animal_name}\n '''\n label\n end\n formated_animal_list\n end",
"def name\n return 'AedgSmallToMediumOfficeExteriorDoorConstruction'\n end",
"def name_with_middle; end",
"def get_name_middleman\n name ? name : 'N/a'\n end",
"def insured_name\n if @eob_type != 'Patient'\n id, qual = @eob.member_id_and_qualifier\n ['NM1', 'IL', '1', @eob.subscriber_last_name, @eob.subscriber_first_name,\n @eob.subscriber_middle_initial, '', @eob.subscriber_suffix, qual,id].trim_segment.join(@element_seperator)\n end\n end",
"def create_array_valid_parking_names\n\t\tvalid_parking_names = [\n\t\t\t'01 MANUEL AZAÑA',\n\t\t\t'02 C C BUENAVISTA',\n\t\t\t'03 ALHÓNDIGA CENTRO CIVICO',\n\t\t\t'04 ESTACIÓN GETAFE CENTRAL',\n\t\t\t'05 PLAZA CARRETAS',\n\t\t\t'06 PLAZA DE ESPAÑA',\n\t\t\t'07 C\\MADRID - DE LA CIERVA',\n\t\t\t'08 C C JUAN DE LA CIERVA',\n\t\t\t'09 RESID. DE ESTUDIANTES',\n\t\t\t'10 FUENTE DE GOYA',\n\t\t\t'11 TRECE ROSAS',\n\t\t\t'12 PARQUE AVIOCAR',\n\t\t\t'13 POLIDEP. ALHÓNDIGA',\n\t\t\t'14 PL. DE LA MAGDALENA'\n\t\t]\n\n\t\treturn valid_parking_names\n\tend",
"def find_mos_models description\n models = {}\n description.downcase.each_line{|l|\n if l =~ /(^ *)([m]\\S*) (\\([^\\)]*\\)) +(\\S+) +(.*)$/\n parms, = parse_parameters $5\n models[$4] ||= []\n models[$4] << {'l'=> parm_eval(parms['l']),\n 'w'=> parm_eval2(parms['w'], parms[NUMBER_OF_FINGERS])}\n end\n }\n models.each_value{|v| v.uniq!}\n end",
"def model_names\n result = []\n ole_obj.Models.each do |el|\n result << el.name\n end\n result\n end",
"def craft_names(rand_words, snippet, pattern, caps=false) # caps defaults to false\n names = snippet.scan(pattern).map do\n word = rand_words.pop()\n caps ? word.capitalize : word\n end\n\n return names * 2 # return the names variable twice as an array\nend",
"def name\n return 'AedgSmallToMediumOfficeRoofConstruction'\n end",
"def species\n return \"human\"\n end",
"def nice_name\n name.gsub(/\\..+/, '').wikify\n end",
"def human_from_name; end",
"def all_name_strings\n names.collect { |a| a.name }\n end",
"def modeler_description\n return \"This measure loops through space types in the model and adjusts the lighting power per area (W/ft2) or lighting power per person (W/person) for affected space types. The measure is not currently able to change the lighting power is specified using the Lighting Level (W) input option.\"\n end"
] |
[
"0.57651305",
"0.57417816",
"0.5643479",
"0.55920374",
"0.5547858",
"0.54366666",
"0.5364352",
"0.53182197",
"0.5275155",
"0.526395",
"0.52516013",
"0.52482516",
"0.52316934",
"0.52212983",
"0.5219748",
"0.52005124",
"0.5198502",
"0.5164443",
"0.5157257",
"0.511221",
"0.510609",
"0.5106044",
"0.5095076",
"0.5082654",
"0.50793755",
"0.50779307",
"0.50779307",
"0.50779307",
"0.50779307",
"0.50779307",
"0.50779307",
"0.50779307",
"0.504123",
"0.5029223",
"0.502255",
"0.5009841",
"0.49900222",
"0.49816215",
"0.4946667",
"0.4944063",
"0.49340826",
"0.49234772",
"0.49224746",
"0.49162206",
"0.49157697",
"0.49034396",
"0.49021256",
"0.489721",
"0.48925215",
"0.4892327",
"0.48908424",
"0.48862138",
"0.48729992",
"0.48729193",
"0.4872888",
"0.48714396",
"0.48702717",
"0.48669115",
"0.48534712",
"0.48534712",
"0.48515546",
"0.48500493",
"0.4839314",
"0.48267445",
"0.4822745",
"0.4818726",
"0.48121518",
"0.4809781",
"0.4806311",
"0.48049432",
"0.4801686",
"0.48009512",
"0.47960508",
"0.4778819",
"0.47784486",
"0.47653788",
"0.4757442",
"0.47560832",
"0.47551993",
"0.47551993",
"0.4754401",
"0.47456518",
"0.47438172",
"0.47381657",
"0.4735908",
"0.47281706",
"0.4721249",
"0.47173312",
"0.47168538",
"0.47168195",
"0.4701161",
"0.4699654",
"0.4692142",
"0.4690497",
"0.46900618",
"0.46840873",
"0.46814752",
"0.46770465",
"0.4670358",
"0.4669841"
] |
0.5453332
|
5
|
Returns the company name tha owns the well Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.company_name => "ANY OIL COMPANY LTD."
|
def company_name
self.well_info.company_name
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def company_name\t\t\t# Getter method - return nil if name is not found\n\t\tcompany.try(:name)\n\tend",
"def company_name\n @company_name\n end",
"def company_name\n object.company.name\n end",
"def company_name\n @company_name\n end",
"def name\n latest_ccla_signature.company\n end",
"def name\n company.blank? ? full_name : \"#{company} (#{full_name})\"\n end",
"def company_name\n element_with_value('CompanyName', opts[:company_name][0..34])\n end",
"def name\n company.blank? ? full_name : \"#{company} (#{full_name})\"\n end",
"def company_name\n element_with_value('CompanyName', opts[:company_name])\n end",
"def company_name\n account.name if account\n end",
"def company_name\n quote.name\n end",
"def name\n self.company.name unless company.nil?\n end",
"def company_name\n name.left_name\nend",
"def company_name\n self.companies.count > 0 ? self.companies.first.title : ''\n end",
"def current_company_name\n begin\n Client.find(current_subdomain).webname\n rescue\n \"\"\n end\n end",
"def company_name\n self.dig_for_string(\"agentSummary\", \"office\", \"companyName\")\n end",
"def name\n \"#{id}-#{company_name}\"\n end",
"def company_name\n Faker::Company.name\n end",
"def company_name\n Faker::Company.name\n end",
"def company\n alliance_company\n end",
"def user_company\n if Client.find_by_id(current_user.client_id)\n Client.find_by_id(current_user.client_id).client_name\n end\n end",
"def service_company\n self.well_info.service_company\n end",
"def company_name(company_name, direction = :push)\n if direction == :push\n company_name[0..82]\n else\n company_name\n end\n end",
"def account_name\n return company.company_name unless company.nil? || company.company_name.nil?\n\n [forename, surname].join(' ')\n end",
"def customer_name\n company.blank? ? full_name : \"#{company} (#{full_name})\"\n end",
"def customer_name\n company.blank? ? full_name : \"#{company} (#{full_name})\"\n end",
"def company\n @attributes[:company]\n end",
"def getcompany\n Company.company_than(need_calc_company)\n end",
"def company\n @company ||= research_param(:company) || company_list.first\n end",
"def company_code\n if self.yard.present? && self.yard.facility.present? && self.yard.facility.country.present?\n country = self.yard.facility.country\n \"COPART#{country.code}\".upcase\n else\n \"\"\n end\n end",
"def thorins_company; end",
"def get_Company(name=nil)\n\n getElement_text(\"cust_vendors\").click\n\n getElement_text(\"Customers\").click\n\n if(name!=nil)\n getElement_text_direct(name).click\n else\n getElement_text(\"company_name_data\").click\n end\n end",
"def name\n if person?\n \"#{lastname}, #{firstname}\"\n else\n company_name\n end\n end",
"def name\n name_business\n end",
"def billing_name\n company.blank? ? full_name : \"#{full_name} (#{company})\"\n end",
"def company; end",
"def company; end",
"def describe_company(company)\n signed_get(COMPANIES_PATH, escape(company))\n end",
"def name_with_locations\n \"#{self.location_one} - #{self.location_two} - #{self.priority} - \" + Company.find(self.company_id).company_name\n end",
"def shipper_name\n element_with_value('Name', opts[:company_name])\n end",
"def guess_company_domain\n if self.company_domain.blank?\n string = self.company_name.to_s.downcase.gsub(' ', '') + \".fr\"\n self.company_domain = string\n end\n end",
"def get_company\n @company ||= current_company\n end",
"def to_s\n company\n end",
"def update_company company_name\n if self.valid?\n unless company_name.nil?\n company_name = company_name.strip\n if company_name.blank?\n self.company_id = 0\n self.company_name = ''\n else\n company = Company.find_or_create_by_name company_name\n unless company.id == self.company_id\n self.company_id = company.id\n self.company_name = company.name\n end\n end\n end\n end\n end",
"def current_company\n Company.find(1)\n end",
"def identificacion_company\n \"#{type_identification}-#{rif}\"\n end",
"def comp_2_name\n comp = Competitor.find_by_id(self.comp_id_2)\n name = comp.name\n return name\n end",
"def company_name_beta(companies)\n companies.find do |company|\n if company.name == 'Beta'\n company\n end\n end \nend",
"def lookup(company)\n cfpb_name = fuzzy_cfpb_lookup(company).first || {}\n iex_name = match_cfpb_to_iex(cfpb_name) || {}\n\n { cfpb: cfpb_name['name'], iex: iex_name['name'] }\n end",
"def well_name\n self.well_info.well_name\n end",
"def current_company\n Company.find(:first)\nend",
"def name\n self.compra.name\n end",
"def company\n response = JSON.parse(@client.get(\"users/#{send(:id)}/companies\").body)\n Promisepay::Company.new(@client, response['companies'])\n rescue Promisepay::NotFound\n nil\n end",
"def name\n @trading_name || @other_trading_name || @main_name || @legal_name || @legal_name2 || 'Name unknown'\n end",
"def org_name\n self.org.try(:name).to_s\n end",
"def suffix\n fetch('company.suffix')\n end",
"def org_name\n (org = self.organization) && org.name\n end",
"def company_name=(company_name)\n if !company_name.nil? && company_name.to_s.length < 0\n fail ArgumentError, 'invalid value for \"company_name\", the character length must be great than or equal to 0.'\n end\n\n @company_name = company_name\n end",
"def fio_from_company_name\n if ogrn.to_s.length == 15\n values = company_name.to_s.split(' ').select(&:present?).map(&:capitalize)\n { first_name: values[1], \n last_name: values[0], \n patronymic_name: values[2] }\n else\n { first_name: UNKNOWN_NAME, \n last_name: UNKNOWN_NAME, \n patronymic_name: UNKNOWN_NAME }\n end\n end",
"def set_company_name\n @company_name = CompanyName.find(params[:id])\n end",
"def company=(v)\n Axlsx.validate_string v\n @company = v\n end",
"def get_campus_name(doc)\n admin_set = doc.admin_set.title.first.to_s\n Hyrax::CampusService.get_campus_from_admin_set(admin_set)\n end",
"def list_portfolio_companies\n self.companies.map do |company_instance|\n company_instance.name\n end\n end",
"def con_name\n @data_object.con_first_name.to_s +\n \" \" +\n @data_object.con_last_name.to_s\n end",
"def full_name\n return \"\" if self.curriculum_core.blank?\n \"#{self.curriculum_core.name}, #{self.name}\"\n end",
"def plausible_common_name\n parse('creature.bird.plausible_common_names').capitalize\n end",
"def catch_phrase\n Faker::Company.catch_phrase\n end",
"def catch_phrase\n Faker::Company.catch_phrase\n end",
"def getorganizationname()\r\n return getvalue(SVTags::ORGANIZATION_NAME)\r\n end",
"def main_co\n companies.main.first \n end",
"def full_name\n \"#{brand.name} #{name} (#{vehicle_type.name})\"\n \n end",
"def competitor_name(competitor_id)\n comp = Competitor.find_by_id(competitor_id)\n name = comp.name\n return name\n end",
"def company_name=(company_name)\n if company_name.nil?\n fail ArgumentError, 'company_name cannot be nil'\n end\n\n if company_name.to_s.length < 1\n fail ArgumentError, 'invalid value for \"company_name\", the character length must be great than or equal to 1.'\n end\n\n @company_name = company_name\n end",
"def cname\n self[:cname] || domain_names&.first&.canonicalize_cname\n end",
"def cname\n self[:cname] || domain_names&.first&.canonicalize_cname\n end",
"def company_info\n company_info ||= CompanyLeave.for_company(company).first\n end",
"def combined_name\n self.FirstName + \" \" + self.LastName + \" \" + self.Company\nend",
"def get_grand_company(page)\n gc = nil\n lines = page.grep(/txt_name/)\n\n # checks to see if the optional free company line has been added\n fc = lines.grep(/a href=/)\n\n # GOOD CONDITIONS\n # 5 lines, guarentees they're in a GC\n # 4 lines if they're NOT in an FC, otherwise the 4th line is FC\n if lines.length < 4 || (lines.length == 4 && ! fc.empty?)\n return gc\n else\n # Make name of grand company the beginning of the line\n line = lines[3][25..-1]\n # Get the name on it's own\n line = line.split('/')\n gc = line[0]\n end\n end",
"def get_grand_company(page)\n gc = nil\n lines = page.grep(/txt_name/)\n\n # checks to see if the optional free company line has been added\n fc = lines.grep(/a href=/)\n\n # GOOD CONDITIONS\n # 5 lines, guarentees they're in a GC\n # 4 lines if they're NOT in an FC, otherwise the 4th line is FC\n if lines.length < 4 || (lines.length == 4 && ! fc.empty?)\n return gc\n else\n # Make name of grand company the beginning of the line\n line = lines[3][25..-1]\n # Get the name on it's own\n line = line.split('/')\n gc = line[0]\n end\n end",
"def current_company() # :doc:\n current_user.full?(&:company)\n end",
"def coll_name\n return coll.college_name\n end",
"def set_CompanyName(value)\n set_input(\"CompanyName\", value)\n end",
"def name\n self.curriculum.name\n end",
"def company\n @company ||= Company.find(params[:id])\n end",
"def name\n return @person_name if @person_name\n\n if @key_names\n if @names_before_key\n return \"#{@names_before_key} #{@key_names}\"\n else\n return @key_names\n end\n end\n\n @corporate_name\n end",
"def organisation_name\n return if partnership?\n\n organisation.name\n end",
"def before_create\n # Cloned so we can pass objects as name parameter to new Company\n self.name = self.name.clone.normalize!\n super\n end",
"def distributor_name\n \tdistributor = Tbpl2003acc_Master.where(acc_code: self.distcode)\n \tif distributor.present?\n \t\tdistributor.first.acc_name\n \telse\n \t\t\"NA for #{self.distcode}\"\n \tend\n end",
"def name_for_clearinghouse \n clearinghouse_customer_name || name\n end",
"def app_company\n 'BarkerEST'\n end",
"def current_company\n current_user ? current_user.company : nil\n end",
"def show_path_for_company(current_user,company)\n if current_user.nil? then\n link_to \"#{company.com_name}\", company_path(company) \n else\n link_to \"#{company.com_name}\", [current_user,company] \n end\n end",
"def name\n return 'AedgSmallToMediumOfficeRoofConstruction'\n end",
"def company_id\n if @company.respond_to?(:to_hash)\n @company.fetch(:company_id) { @company }\n elsif @company.respond_to?(:company_id)\n @company.company_id\n else\n @company\n end\n end",
"def task_name_company\n [executor.try(:profile).try(:first_name), executor.try(:profile).try(:last_name), executor.try(:profile).try(:company)].join(' ')\n end",
"def task_name_company\n [executor.try(:profile).try(:first_name), executor.try(:profile).try(:last_name), executor.try(:profile).try(:company)].join(' ')\n end",
"def carwash_city_name\n\t\t\tobject.city.name\n\t\tend",
"def company\n if teacher? || !self.group\n return nil\n else\n self.group.company\n end\n end",
"def soffice_pname\n 'soffice'\n end",
"def owner\n self.company.present? ? self.company.owner : self\n end"
] |
[
"0.7688148",
"0.7644459",
"0.7523862",
"0.74599236",
"0.73722374",
"0.733742",
"0.7231664",
"0.71790296",
"0.7172417",
"0.71318823",
"0.7102993",
"0.7085619",
"0.6997876",
"0.6976442",
"0.6913566",
"0.68805295",
"0.68650687",
"0.683369",
"0.683369",
"0.6803127",
"0.6766914",
"0.6731195",
"0.6643675",
"0.6615764",
"0.65706754",
"0.65706754",
"0.6542387",
"0.6501424",
"0.64734566",
"0.64725983",
"0.64723223",
"0.64677435",
"0.64015234",
"0.6339631",
"0.6287473",
"0.6206237",
"0.6206237",
"0.6195102",
"0.6124143",
"0.6119591",
"0.6060027",
"0.6051693",
"0.6050653",
"0.60234123",
"0.60155284",
"0.59850746",
"0.5965043",
"0.59622204",
"0.5952834",
"0.5880515",
"0.5857505",
"0.58572024",
"0.5850269",
"0.5841126",
"0.58214843",
"0.5819729",
"0.5779266",
"0.5769834",
"0.5755496",
"0.57511854",
"0.5749623",
"0.5738848",
"0.57380176",
"0.5736296",
"0.57349324",
"0.5730138",
"0.57295686",
"0.57295686",
"0.57275784",
"0.571853",
"0.5707851",
"0.57042825",
"0.57042134",
"0.570095",
"0.570095",
"0.5700454",
"0.56934005",
"0.5692784",
"0.5692784",
"0.56722087",
"0.56681454",
"0.5666687",
"0.5653564",
"0.5649271",
"0.5649113",
"0.56461734",
"0.56428075",
"0.564253",
"0.563859",
"0.56373364",
"0.56362575",
"0.5633296",
"0.56246054",
"0.5621456",
"0.56180036",
"0.56180036",
"0.5602953",
"0.5597922",
"0.5590468",
"0.5588952"
] |
0.7886307
|
0
|
Returns the field name described in the file Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.field_name => "CAMPOS"
|
def field_name
self.well_info.field_name
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def field_name\r\n @field_name ||= begin\r\n %r/(\\w+)Field$/.match(name)[1]\r\n rescue\r\n %r/(\\w+)$/.match(name)[1]\r\n end\r\n end",
"def field_name\n self.class.name.split(\"::\").last.downcase.sub(\"of\", \"_of_\"). \\\n sub(\"field\", \"\").downcase\n end",
"def field_name\n @field.name\n end",
"def name\n @name ||= filename.split(\".\").first.sub(/^_/, \"\")\n end",
"def field name\n @fields[name]\n end",
"def primary_solr_name(field, file_path)\n config = self.class.config_for_term_or_uri(field)\n return nil unless config && config.behaviors # punt on index names for deep nodes!\n config.behaviors.each do |behavior|\n result = ActiveFedora.index_field_mapper.solr_name(apply_prefix(field, file_path), behavior, type: config.type)\n return result if Solrizer::DefaultDescriptors.send(behavior).evaluate_suffix(:text).stored?\n end\n raise RuntimeError \"no stored fields were found\"\n end",
"def name\n @name ||= File.basename(file).chomp(File.extname(file))\n end",
"def contact_field_name(contact_field)\n contact_field_translations[contact_field]\n end",
"def get_field(field_name)\n fields = @data_source['fields']\n \n fields.each do | f |\n if f['name'] == filed_name\n return f\n end\n end \n return nil\n end",
"def get_field_name\n\t\tend",
"def object_name\n @name ||= File.split(@source_path).last.gsub('.txt', '')\n end",
"def field(l_name)\n fields.find{|fld| fld.l_name == l_name}\n end",
"def to_field_name(name)\n # camelize strips leading underscores, which is undesirable.\n if name.to_s.starts_with?('_')\n \"_#{to_field_name(name.to_s[1..-1])}\"\n elsif Rails.config.camel_case\n name.to_s.camelize(:lower)\n else\n name.to_s\n end\n end",
"def primary_solr_name(field, file_path)\n config = self.class.config_for_term_or_uri(field)\n return nil unless config # punt on index names for deep nodes!\n if behaviors = config.behaviors\n behaviors.each do |behavior|\n result = ActiveFedora::SolrQueryBuilder.solr_name(apply_prefix(field, file_path), behavior, type: config.type)\n return result if Solrizer::DefaultDescriptors.send(behavior).evaluate_suffix(:text).stored?\n end\n raise RuntimeError \"no stored fields were found\"\n end\n end",
"def nice_name(node)\n name = attr(node)\n defect_fields[name] || name\n end",
"def name() @filename end",
"def file_name\n name.underscore\n end",
"def name\n read_attribute(:pf_name)\n end",
"def name\n filename\n end",
"def name\n filename\n end",
"def name\n read_property('Name') || asmname || proj_filename_noext\n end",
"def file_name\n\t\treturn 'st' + student_id.to_s + 'pr' + problem_id.to_s + 'so' + id.to_s\n\tend",
"def name\n @name ||= section.symstr.name_at(header.st_name)\n end",
"def file_name\n @file_name\n end",
"def name\n self.filename\n end",
"def get_field_name(options)\r\n field_name = options[:field_name]\r\n\r\n field_name\r\n end",
"def get_field(field_name)\n\t\tend",
"def name\n lines[0]\n end",
"def get_string_field(field_name)\n\t\tend",
"def field_name\n @gapi.field_name\n end",
"def model_file_name\n @name.underscore\n end",
"def model_file_name\n @name.underscore\n end",
"def name\n source.longname\n end",
"def name\n self.general_fields.where(fieldable_id: self.id).where(\"payload->>'key' = 'name'\").first.value\n end",
"def field(name); end",
"def name\n read_attribute(:name).try(:titleize)\n end",
"def dynamic_custom_field_class_name(name)\n \"#{self.name}#{name.to_s.singularize.camelize}Field\"\n end",
"def file_name\n self.file_file_name\n end",
"def name\n file.basename('.rb').to_s if file\n end",
"def name\n file.basename('.rb').to_s if file\n end",
"def original_filename\n instance_read(:file_name)\n end",
"def name\n # Note that we have to be clever here and use \"direct access\"\n # to avoid a stack overflow from recursion.\n\n # Alternative would be to have this \"virtual attribute\" named\n # something other than name, or change the database column name.\n self[:name].blank? ? self[:upload_file_name] : self[:name]\n end",
"def field_by_name(name = nil)\n @fields.find { |h| h[:name].to_snym == name.to_snym }\n end",
"def filename\n @name ||= \"#{model.firstname.parameterize}-#{model.lastname.parameterize}.#{model.image.file.extension}\"\n end",
"def field_name(field=nil)\n result = field_name_fragment\n result << \"[#{field}]\" if field\n result\n end",
"def access_file_name\n end",
"def field_human_name(field)\n I18n.translate(\"#{model_name}.attributes.#{field}\", :count => 1, :default => Inflections.humanize(field), :scope => :models)\n end",
"def get_char_field(field_name)\n\t\tend",
"def file_name\n if source\n source.is_a?(File) ? File.basename(source.path) : File.basename(source)\n else\n object.original_name.nil? ? \"original_file\" : object.original_name\n end\n end",
"def name\n file.partition(base).last.gsub(/[_\\/]/, \" \").strip\n end",
"def field\n @field ||= quoted_field(field_name)\n end",
"def name(index)\n i = get_field_index_by_external_id(index,@fields[:name])\n fields(index, i).to_s unless i.nil?\n end",
"def name(index)\n i = get_field_index_by_external_id(index,@fields[:name])\n fields(index, i).to_s unless i.nil?\n end",
"def attribute_field_name(attr)\n attr.to_s.camelize(:lower)\n end",
"def get_fieldnames(filename, options)\n path = \"#{options[:input]}/#{filename}\"\n File.read(path)\n .chomp\n .sub('_version_', '%US%version%US%')\n .gsub(',_', '%COMMA%_')\n .gsub(', ', '%COMMA% ') \n .split(',')\n .reject{ |field| field.start_with?('RELS_EXT_isSequenceNumberOf') }\nend",
"def file name\n \n end",
"def name\n case\n when current_language == :fr && french_name?\n read_attribute(:name_fr)\n\n when current_language == :fr && english_name?\n read_attribute(:name)\n\n when current_language != :fr && english_name?\n read_attribute(:name)\n\n when current_language != :fr && french_name?\n read_attribute(:name_fr)\n\n else\n ''\n end\n end",
"def get_F32_field(field_name)\n\t\tend",
"def name\n return @name unless @name.nil?\n io = _parent.strings._io\n _pos = io.pos\n io.seek(ofs_name)\n @name = (io.read_bytes_term(0, false, true, true)).force_encoding(\"UTF-8\")\n io.seek(_pos)\n @name\n end",
"def field(name)\n attr_accessor name\n end",
"def name\n @name ||= File.basename(path)\n end",
"def name\n @name ||= File.basename(path)\n end",
"def filename\n @data[:name]\n end",
"def filename\r\n Chingu::Inflector.underscore(self.class.to_s)\r\n end",
"def getName; @name; end",
"def file_name\n @file_name ||= File.basename tree\n end",
"def filename\n @file.basename.to_s\n end",
"def file_name\n \"#{@file_name}.#{extension}\"\n end",
"def file_name\n return @file_name\n end",
"def file_name\n return @file_name\n end",
"def file_form_field\n @attributes[:file_form_field]\n end",
"def translation_for(field)\n object.class.human_attribute_name(field)\n end",
"def name\n @name ||= self.to_s.demodulize.underscore\n end",
"def name(value = nil)\n if value\n field_type.name(value)\n else\n # Return the name of the field\n @name\n end\n end",
"def file_name\n uploaded_file_file_name\n end",
"def name\n @name ||= ::File.basename(@path)\n end",
"def label_for(file)\n if file.is_a?(Hyrax::UploadedFile) # filename not present for uncached remote file!\n file.uploader.filename.present? ? file.uploader.filename : File.basename(Addressable::URI.parse(file.file_url).path)\n elsif file.respond_to?(:original_name) # e.g. Hydra::Derivatives::IoDecorator\n file.original_name\n elsif file_set.import_url.present?\n # This path is taken when file is a Tempfile (e.g. from ImportUrlJob)\n File.basename(Addressable::URI.parse(file_set.import_url).path)\n else\n File.basename(file)\n end\n end",
"def name\n @name ||= File.basename(path)\n end",
"def external_name\n @external_name ||= \"#{normalized_affixe_from_titre}.tex\"\n end",
"def getname(f, entryptr)\n f.seek(entryptr + 12) # three ptrs then name\n str = f.read(8)\n return str\n end",
"def field\n @field ||= @options.fetch(:field, repository.adapter.field_naming_convention.call(name))\n end",
"def name\n definition[:name]\n end",
"def label_for(file)\n if file.is_a?(Hyrax::UploadedFile) # filename not present for uncached remote file!\n file.uploader.filename.presence || File.basename(Addressable::URI.unencode(file.file_url))\n elsif file.respond_to?(:original_name) # e.g. Hydra::Derivatives::IoDecorator\n file.original_name\n elsif file_set.import_url.present?\n # This path is taken when file is a Tempfile (e.g. from ImportUrlJob)\n File.basename(Addressable::URI.unencode(file.file_url))\n elsif file.respond_to?(:original_filename) # e.g. Rack::Test::UploadedFile\n file.original_filename\n else\n File.basename(file)\n end\n end",
"def name\n internal_name\n end",
"def name(language = nil)\n language ||= Language.current\n vernacular(language).try(:string) || scientific_name\n end",
"def file_name\n return unless @file\n\n @file.absolute_name\n end",
"def construct_file_label( number, source_name, generic_work )\n\n unknown = 'UNKNOWN'\n last_name = generic_work.author_last_name.blank? ? unknown : generic_work.author_last_name.split( ' ' ).first\n first_name = generic_work.author_first_name.blank? ? unknown : generic_work.author_first_name.split( ' ' ).first\n year = generic_work.date_published.blank? ? unknown : generic_work.date_published\n degree = generic_work.degree.blank? ? unknown : generic_work.degree.split( ' ' ).first\n suffix = File.extname( source_name )\n\n return \"#{number}_#{last_name}_#{first_name}_#{year}_#{degree}#{suffix}\"\n end",
"def field_name\n case @cmd_switch\n when 'add_forgroups'\n 'dc.subject.forgroup'\n\n when 'replace_type'\n 'dc.type'\n\n else\n STDERR.puts \"Invalid command line switch: #{@cmd_switch}\"\n exit 1\n end\n end",
"def field_def(name)\n @@known_fields_lookup[name] || # the fast way\n @@known_fields.find{|hfd| hfd === name} || # the slow way\n FieldDesc.new(name.to_s.downcase.gsub(/^.|[-_\\s]./) { |x| x.upcase }.gsub('_', '-'), :repeatable => true) # make up as we go\n end",
"def filename\n @file\n end",
"def name\n @content[pn(:Name)]\n end",
"def file_name\n File.basename(file_path)\n end",
"def real_name\n name\nend",
"def get_field(key)\n @form_fields.getField key.to_s\n end",
"def transform_field_name(key, name)\n hash = ::CUSTOM_FIELD_NAMES\n class_name = self.class.name.demodulize.underscore.to_sym\n return name if hash.nil? || hash[class_name].nil? || hash[class_name][key.to_sym].nil?\n hash[class_name][key.to_sym]\n end",
"def name\n \"#{self[:asn]} #{self[:vrf]} #{self[:afi]} #{self[:safi]} #{self[:aa]}\"\n end",
"def get_name\n return \"#{name}\"\n end",
"def get_flexi_label\n labels = [_flexi_metadata[:label_singular],\n _flexi_metadata[:label_plural]].compact\n\n if labels.empty?\n _f_name = _friendly_name(self.name)\n [_f_name.singularize, _f_name.pluralize]\n else\n labels\n end\n end",
"def name\n \"#{self.subject.try(:name)} #{self.curriculum_grade.try(:name)}.#{self.curriculum_area.try(:name)}.#{self.standard}\"\n end",
"def assignment_upload_file_name\n read_attribute(:file_name)\n end"
] |
[
"0.66984063",
"0.6500637",
"0.6321359",
"0.6127486",
"0.603498",
"0.6028319",
"0.6027831",
"0.5945752",
"0.59320956",
"0.5923208",
"0.5861244",
"0.5850968",
"0.582545",
"0.58120346",
"0.5811522",
"0.580928",
"0.5802823",
"0.57921726",
"0.5756785",
"0.5756785",
"0.5729316",
"0.57229996",
"0.57117784",
"0.5695616",
"0.5690561",
"0.56741786",
"0.56680477",
"0.56646925",
"0.56587726",
"0.5654819",
"0.5653911",
"0.5653911",
"0.5643521",
"0.5621997",
"0.55932814",
"0.5591668",
"0.55909204",
"0.5582417",
"0.55806625",
"0.55806625",
"0.5571247",
"0.5564769",
"0.55091274",
"0.54965436",
"0.5495487",
"0.5492935",
"0.54927874",
"0.5491398",
"0.5488398",
"0.54883826",
"0.54872155",
"0.54862934",
"0.54862934",
"0.5473429",
"0.5469512",
"0.5461393",
"0.5460242",
"0.5451811",
"0.5448541",
"0.5447583",
"0.5444675",
"0.5444675",
"0.5440198",
"0.54342085",
"0.5425644",
"0.54177916",
"0.5407141",
"0.5403854",
"0.54036295",
"0.54036295",
"0.5393271",
"0.5389767",
"0.5386031",
"0.53819185",
"0.5381857",
"0.5377043",
"0.53744185",
"0.53704256",
"0.53686523",
"0.5363399",
"0.5359023",
"0.53574526",
"0.53567743",
"0.535492",
"0.534901",
"0.53468215",
"0.5343672",
"0.5342178",
"0.5336633",
"0.53276503",
"0.5327087",
"0.53192747",
"0.5318074",
"0.5311775",
"0.5311486",
"0.5310866",
"0.5308414",
"0.5296546",
"0.52784455",
"0.5278092"
] |
0.6367217
|
2
|
Returns the location described in the file Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.location => "43.173871636390686 22.964858960678484"
|
def location
self.well_info.location
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def location\n fetch('hey_arnold.locations')\n end",
"def location\n fetch('sword_art_online.location')\n end",
"def location\n fetch('simpsons.locations')\n end",
"def location\n @location ||= Station.get(@attrs['LocationCode'])\n end",
"def get_location\n\n end",
"def location\r\n infoxml = get_info\r\n return infoxml.at('location').inner_text\r\n end",
"def location\n attributes.fetch(:location)\n end",
"def location\n fetch('games.super_mario.locations')\n end",
"def location\n fetch('harry_potter.locations')\n end",
"def location\n fetch('books.the_kingkiller_chronicle.locations')\n end",
"def location\n fetch('rick_and_morty.locations')\n end",
"def location\n fetch('how_to_train_your_dragon.locations')\n end",
"def location\n ln = location_name\n return nil if ln == \"\" || ln == nil\n @engine.item_by_name(location_name)\n end",
"def location_name\n LOCATIONS[location.to_s]\n end",
"def location_name\n LOCATIONS[location.to_s]\n end",
"def location_name\n LOCATIONS[location.to_s]\n end",
"def location_name\n LOCATIONS[location.to_s]\n end",
"def location\n\t\tif @location\n\t\t\t@location\n\t\telsif File.exists?(default_location)\n\t\t\tdefault_location\n\t\telsif File.exists?(appstore_location)\n\t\t\tappstore_location\n\t\telse\n\t\t\tnil\n\t\tend\n\tend",
"def location\n fetch('doraemon.locations')\n end",
"def location\n return @location\n end",
"def location\n @location\n end",
"def location\n @location\n end",
"def getLocation\r\n\t\t\t\t\treturn @location\r\n\t\t\t\tend",
"def location\n @ole.Location\n end",
"def physical_location_str\n mods_ng_xml._location.physicalLocation.map(&:text).find do |text|\n text =~ /.*(Series)|(Accession)|(Folder)|(Box).*/i\n end\n end",
"def location\n @netcdf_elmt.getLocation() \n end",
"def location_info(location = locations.first)\n if location\n location.full_location\n else\n []\n end\n end",
"def location\n \"#{@position} #{DIRECTIONS[@orientation]}\"\n end",
"def location\n\t\tif machine.blank?\n\t\t\t\"Location Unknown\"\n\t\telsif usage.blank?\n\t\t\t\"#{machine.name}\"\n\t\telse\n\t\t\t\"#{machine.name} (#{usage})\"\n\t\tend\n\tend",
"def location\n fetch('games.league_of_legends.location')\n end",
"def location\n # TODO Check this\n # return poi.location unless poi.nil?\n # return place.location unless place.nil?\n return get_location\n end",
"def location_s\n self.location.to_s\n end",
"def location\n @location\n end",
"def location\n l = line()\n if l == 0\n \"#{file}+#{ip-1}\"\n else\n \"#{file}:#{line}\"\n end\n end",
"def location\n translate! attribute('yweather:location')\n end",
"def location\n\t\t@location\n\tend",
"def location\n ensure_full_data!\n @gapi[\"location\"]\n end",
"def to_s\n location\n end",
"def full_location; end",
"def location_variable_name_of_lasgn(path)\n type! :LASGN\n first_index = first_index(path)\n\n Location.new(first_index, first_index + self.children[0].size - 1)\n end",
"def return_location(location, line)\n\t\n\nend",
"def location\n ans = location_answers.first\n ans ? ans.location : nil\n end",
"def location\n @location\n end",
"def location\n Location.get(@entity['location_id'], client: @client)\n end",
"def location\n @client.get(\"#{path}/location\")\n end",
"def location\n response[\"location\"]\n end",
"def location\n\t\tStructureLocation.new(@db, @id)\n\tend",
"def _location_path(location)\n location.match(/^(\\.\\/)?(.*?)(:\\d+)?$/)[2]\n end",
"def locate(location)\n get :q => location.is_a?(String) ? location : location_from_params(location).to_s, :output => 'locations'\n end",
"def path\n if location =~ /^\\/dev/\n \"dev:#{location}\"\n elsif location =~ /iso$/\n \"iso:#{location}\"\n elsif location.is_a?(Integer)\n \"disc:#{location}\"\n elsif location =~ /^disc/\n location\n else\n raise RuntimeError\n end\n end",
"def path\n if location =~ /^\\/dev/\n \"dev:#{location}\"\n elsif location =~ /iso$/\n \"iso:#{location}\"\n elsif location.is_a?(Integer)\n \"disc:#{location}\"\n elsif location =~ /^disc/\n location\n else\n raise RuntimeError\n end\n end",
"def location\n @gapi[\"location\"]\n end",
"def getSeqLoc\n if ARGV.length == 4\n strand = ARGV[2]\n location = ARGV[1]\n else\n abort \"You need to specify location and strand !\"\n end\n loc = location.split(\"..\")\n bioSeq = @gbkObj.to_biosequence\n if strand.to_i == -1\n sequence = Bio::Sequence.new(bioSeq.subseq(loc[0].to_i,loc[1].to_i).reverse_complement)\n elsif strand.to_i == 1\n sequence = Bio::Sequence.new(bioSeq.subseq(loc[0].to_i,loc[1].to_i))\n else\n abort \"Bad Strand : 1 or -1 needed\"\n end\n puts sequence.output_fasta(\"#{bioSeq.accessions[0]}|#{loc[0]}..#{loc[1]}|#{strand}\",60)\n end",
"def to_s\n @location\n end",
"def to_s\n @location\n end",
"def get_current_location\n\t \tif Rails.env.test? || Rails.env.development?\n\t \t\t[43.648209, -79.397865] # Hello HackerYou!\n\t \telse\n\t \t\trequest.location\n\t \tend\n\t end",
"def LocationPath(path, parsed); end",
"def location\n if questioning.question.qtype_name == 'location' && !value.blank?\n value.split(' ')\n else\n nil\n end\n end",
"def get_location\n parts = caller[1].split(':')\n @location = \"Near Line # #{parts[1]} in file #{parts[0]}\"\n end",
"def path\n @location.path\n end",
"def file_location(options={})\n self.class.file_location(options)\n end",
"def location\n country = Carmen::Country.coded(self.country)\n if country.present? && self.state.present?\n location = country.subregions? ? country.subregions.coded(self.state).name : self.state\n location += \", \"\n else\n location = ''\n end\n country.present? ? location + country.name : nil\n end",
"def location_code\n text(data.at_xpath(\"#{data_root}/did/physloc\"))\n end",
"def location\n result_hash['loc']\n end",
"def location\n @location ||= person.location unless person.building_address_line_1 == person.location\n end",
"def location_path\n @grpc.location\n end",
"def format_location diagnostic\n file = diagnostic.file\n line = diagnostic.source_pos.line\n pos = diagnostic.source_pos.pos\n if file && line && pos\n \" at #{file}:#{line}:#{pos}\"\n elsif file and line\n \" at #{file}:#{line}\"\n elsif line && pos\n \" at line #{line}:#{pos}\"\n elsif line\n \" at line #{line}\"\n elsif file\n \" in #{file}\"\n else\n \"\"\n end\n end",
"def location\n unless @location\n cursor = html % 'h3 > b > a:first-of-type'\n cursor = cursor.next if cursor \n @location = $1 if cursor and LOCATION_NAME.match he_decode(cursor.to_s)\n end\n \n @location\n end",
"def location\n # and call a private getter method within\n puts \"I live on #{address.split[1]} street.\"\n end",
"def line\n location.line\n end",
"def location=((filename, lineno))\n @filename = filename\n @lineno = lineno if lineno\n end",
"def location_description\n LOCATION_DESCRIPTION\n end",
"def line\n location&.line\n end",
"def location\n [\n (filename || \"<input>\"),\n lineno,\n column,\n ].compact.join(\":\")\n end",
"def location\n [\n (filename || \"<input>\"),\n lineno,\n column,\n ].compact.join(\":\")\n end",
"def location\n @location ||= locations.hq.first\n end",
"def location\n\t\tUnitLocation.new(@db, @id)\n\tend",
"def location_string\n if location\n str = location.name\n str += \", \" + location_text unless location_text.blank?\n else\n str = location_text\n end\n str\n end",
"def generate_location\n raise \"Cannot generate default location for #{self.class}, I don't know how\"\n end",
"def my_location\n\t\t\"#{address}, #{city}, GA\"\n\tend",
"def location\n @fog_wrapper.location\n end",
"def location\n @location ||= TermuxRubyApi::SubSystems::Location.new(self)\n end",
"def location\n return nil if reference?\n ensure_full_data!\n @gapi_json[:location]\n end",
"def in_file_location(out)\n out << \"#{@row = 1} at #{@column = 1} at #{@length}\"\n end",
"def source_location\n source_component.source_location\n end",
"def location\n b = []\n b << latitude\n b << longitude\n Geocoder.coordinates(b)\n end",
"def location\n [lat.to_f / 100_000, lng.to_f / 100_000]\n end",
"def location_name\n pos = @state[\"position\"]\n pos ? pos.split(\"#\",2)[0] : nil\n end",
"def location=(name)\n opts = get_options\n opts['lib']=name\n save_file(opts)\n nil\n end",
"def location\n @location_cache || self.locations[0]\n end",
"def get_location_info(place,final_location)\n place = place + \"\\n\" #New line command is added to ensure equivalency with the file contents for comparison proess\n\n #Open the file that contains all the locations\n location_file = open('location.txt','r')\n\n #reads all the lines in the file and stores them in an array called \"a\"\n a = IO.readlines('location.txt')\n\n #Loop through the array called \"a\"\n for i in 0..location_file.size-1\n if a[i]==place # if a match is found, it will store all the other information into the variables of the final_location class\n final_location.name = a[i]\n final_location.address = a[i+1] #index value is added because the other information are stored in the next few indexes after the name of the location\n final_location.cuisine = a[i+2]\n final_location.healthy = a[i+3]\n final_location.halal = a[i+4]\n final_location.price = a[i+5]\n end\n end\n\n #close the file after use\n location_file.close()\nend",
"def location(value)\n @ole.Location = value\n nil\n end",
"def location\n @gapi.job_reference.location\n end",
"def lon\n @position[1]\n end",
"def define_location\n config\n mtime = File.mtime(@msrun.rawfile)\n arr = [@msrun.group, @msrun.user, \"#{mtime.year}#{\"%02d\" % mtime.mon}#{\"%02d\" % mtime.day}\", @msrun.rawid]\n t = Time.now\n @location = File.join(arr.zip( [\"Unknown\", \"unknown\", \"#{t.year}#{\"%02d\" % t.mon}#{\"%02d\" % t.day}\", \"Never see this\"] ).map {|a| a.first.nil? ? a.last : a.first } )\n @msrun.archive_location = @location\n end",
"def get_location(io, context)\n generate_location(io, context)\n end",
"def locationPosition _args\n \"locationPosition _args;\" \n end",
"def location_name\n location ? location.common_name : nil\n end",
"def get_location(loc)\n geo = Geocoder.search(\"#{loc} seattle\")\n lat = geo[0].latitude\n lon = geo[0].longitude\n [lon, lat]\n end",
"def final_location\n\t\t@roo.location\n\tend"
] |
[
"0.6697898",
"0.65045166",
"0.6493569",
"0.64308834",
"0.6367448",
"0.6348848",
"0.63199323",
"0.63088864",
"0.62945867",
"0.6290822",
"0.62611866",
"0.62571025",
"0.6244376",
"0.6241208",
"0.6241208",
"0.6241208",
"0.6241208",
"0.6225891",
"0.61907434",
"0.61326987",
"0.6113425",
"0.6113425",
"0.61081636",
"0.6105111",
"0.60761905",
"0.6057077",
"0.60569113",
"0.60472244",
"0.6045831",
"0.60244185",
"0.601219",
"0.6011274",
"0.6004836",
"0.5979092",
"0.59730464",
"0.59539104",
"0.59522605",
"0.593652",
"0.5924286",
"0.5899303",
"0.5873041",
"0.5853065",
"0.5845483",
"0.58298284",
"0.58128804",
"0.5812294",
"0.58025354",
"0.5789749",
"0.577951",
"0.57739615",
"0.57739615",
"0.5768774",
"0.5755315",
"0.57537377",
"0.57537377",
"0.5717574",
"0.570948",
"0.56961286",
"0.5694832",
"0.56890583",
"0.56683034",
"0.56677246",
"0.566438",
"0.56512",
"0.5631194",
"0.56294054",
"0.5628389",
"0.5622261",
"0.5620506",
"0.5614057",
"0.5605568",
"0.5604967",
"0.5604416",
"0.560111",
"0.560111",
"0.558942",
"0.55876034",
"0.5571604",
"0.55670255",
"0.5564527",
"0.5563593",
"0.5542532",
"0.55392265",
"0.5537775",
"0.5529559",
"0.5506972",
"0.55000937",
"0.54973316",
"0.549674",
"0.54897094",
"0.5488238",
"0.5465307",
"0.54542744",
"0.5452574",
"0.5446242",
"0.5441747",
"0.54407054",
"0.5438353",
"0.54293877",
"0.5425324"
] |
0.63861203
|
4
|
Returns the province described in the file Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.province => "RIO DE JANEIRO"
|
def province
self.well_info.province
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def province\n ::Province.find_by(contabilium_id: self.IdProvincia)\n end",
"def province\n sale.province\n end",
"def province\n self.municipality.province\n end",
"def find_province_terrain(province_data)\n v = province_data[3]\n v = \"urban\" if urban_province_types.include?(v)\n # v = \"urban\" if victory_points.include?(current_province[0].to_i)\n v\n end",
"def to_s\n province_name\n end",
"def xml_region\n [province.try(:name_en), city].reject(&:blank?).join(', ')\n end",
"def provinces\n Province.where(\"provinces.province_number = :id\", id: id)\n end",
"def get_provinces(country_id, user)\n res = session.request(\"CakeMail::API::ClassCountry\", \"GetProvinces\", { :country_id => country_id, :user_key => user.user_key })\n return res['province']\n end",
"def abbr\n province.try(:abbr) || country.abbr\n end",
"def state_province_code\n @root.xpath('./ns:StateProvinceCode/text()').to_s\n end",
"def institution_name\n @institution_name ||= File.read(file_path, :mode => \"rb\", :external_encoding => \"UTF-8\").strip\n rescue\n nil\n end",
"def expand_province(prov)\n PROVINCE_ABBREVIATION_MAP.fetch(prov.downcase.to_sym, prov)\n end",
"def state_or_province\n end",
"def office_state_province\n self.dig_for_string(\"agentSummary\", \"office\", \"officeAddress\", \"stateProvince\")\n end",
"def label\n namestr = @name == '' ? '' : \", #{@name}\"\n \"#{@province.name}#{namestr}\"\n end",
"def final_map_name\n \"#{@province.name}.geojson\"\n end",
"def load_english_a\n File.open(\"test/test_files/english_a.txt\", \"r\").read\n end",
"def has_province?\n !!province_c\n end",
"def state_or_province\n end",
"def province_dir_path\n @dataset_file_path.gsub(/(.+)\\.geojson$/, '\\1')\n end",
"def show\n @province = Province.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n end\n end",
"def office_state_province_code\n self.dig_for_string(\"agentSummary\", \"office\", \"officeAddress\", \"stateProvinceCode\")\n end",
"def province_id_to_titles\n @province_id_to_titles ||= begin\n map = {}\n glob(\"history/provinces/*.txt\").each do |path|\n id = path.basename.to_s.to_i\n title = parse(path)[\"title\"]\n map[id] ||= []\n map[id] << title\n end\n map\n end\n end",
"def province_ids\n @world.provinces.keys\n end",
"def get_province_by_id\n province = (!params['id'].nil?) ? Province.find_by(id: params['id']) : nil\n if (!province.nil?)\n render json: {status: 'SUCCESS', message:'Province found', data:province},status: :ok\n else\n render json: {status: 'ERROR', message:'Province not found', data:nil},status: :not_found\n end \n end",
"def own_reg_file_path\n \"#{@data_dir}/#{PathConstants::REGIONS_DIR}/#{@province.reg.filename}.geojson\"\n end",
"def find_language\r\n #Find the language based on the path\r\n PropertyFileAttributes::LOCALES.each do |l|\r\n if @filename.index(l)\r\n @language = l\r\n end\r\n end\r\n #If the language is not indicated assume it is English\r\n if @language == nil\r\n @language = PropertyFileAttributes::LOCALES[0] #\"Default\"\r\n end\r\n end",
"def prov_dataset_file_path\n \"#{@tmp_dir}/#{@province.code}-6.geojson\"\n end",
"def state_or_province\n decode hash[\"StateOrProvince\"]\n end",
"def show\n @province = Province.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @province }\n end\n end",
"def district\n parts[1]\n end",
"def index\n @provinces = Province.all\n @default_province_id = Setting.obtain 'default-province'\n end",
"def set_hr_config_province\n @hr_config_province = Hr::Config::Province.find(params[:id])\n end",
"def import_provinces\n Province.destroy_all\n print_title('importing provinces')\n File.open 'db/1_sql_insert_province.sql', 'r' do |file|\n while row = file.gets\n row.strip!\n columns = /.+\\(\\d+,'(\\d+)','(.+)'\\)/.match(row)\n code = columns[1]\n name = columns[2]\n province = Province.create(code: code, name: name)\n print_content \"imported province: #{province.id}, #{province.code}, #{province.name}\"\n end\n end\n print_summary \"total imported provinces count: #{Province.count}\"\nend",
"def load_regions\n YAML.load_file(\"#{root_path}/config/countries.yml\")\n end",
"def GetPlatformOfFile ( fl )\n platforms = { \"a1\" => \"AQUA-1\", \"t1\" => \"TERRA-1\", \"npp\" => \"NPP\"}\n \n x = File.basename(fl).split(\".\").first\n puts x\n return platforms[x] if ( platforms[x])\n return \"unknown\"\nend",
"def create\n @province = Province.new(params[:province])\n\n respond_to do |format|\n if @province.save\n format.html { redirect_to(@province, :notice => l(:notice_successful_create)) }\n format.xml { render :xml => @province, :status => :created, :location => @province }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @province.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def district\n format.split(\" \")[0]\n end",
"def polyglot_language_name\n language.name.split[0].downcase\n end",
"def set_admin_province\n @admin_province = Province.find(params[:id])\n end",
"def address_state_province=(v)\n @address_state_province = alma_string v\n end",
"def country_to_culture\n @country_to_culture ||= begin\n result = {}\n glob(\"history/countries/*.txt\").each do |path|\n tag = path.basename.to_s[0,3]\n node = parse(path)\n result[tag] = node[\"primary_culture\"]\n end\n result\n end\n end",
"def combined_file_path\n \"#{@tmp_dir}/#{@province.code}-combined.geojson\"\n end",
"def french_ssn_info(ssn)\n if ssn == '' # If ssn is an empty string, we return 'The number is invalid'\n return 'The number is invalid'\n else # otherwise..\n file = YAML.load_file('data/french_departments.yml') # we load up the .yml file containing all the French districts - it is loaded in as a hash automatically\n gender = ssn.match(PATTERN)[1] # We retrieve match group 1 - gender\n year = ssn.match(PATTERN)[2] # We retrieve match group 2 - year\n month = ssn.match(PATTERN)[3] # We retrieve match group 3 - month\n department = ssn.match(PATTERN)[4] # We retrieve match group 4 - department\n\n # We return a string interpolating in our variable above\n # If gender is 1, we interpolate man, otherwise woman\n # We access the MONTHS hash using the month key MONTHS['12'] => 'December'\n # We access the yml file hash, and use the department variable as they key\n return \"a #{gender == '1' ? 'man' : 'woman'}, born in #{MONTHS[month]}, 19#{year} in #{file[department]}.\"\n end\nend",
"def get_construction_name()\n get_keyword_value(\"CONSTRUCTION\")\n end",
"def set_provinces\n @provinces = Province.where(country: \"USA\")\n end",
"def english_model_file\n ENGLISH_MODEL_FILE\n end",
"def get_construction_name()\n get_keyword_value(\"CONSTRUCTION\")\n end",
"def current_city_text\n city = ChinaCity.get(self.city)\n city = ChinaCity.get(self.province) if %w(市辖区 县).include?(city)\n city\n end",
"def state_province_field\n $tracer.trace(format_method(__method__))\n\treturn ToolTag.new(@tag.find.span.className(create_ats_regex_string(\"ats-state\")).find.input, format_method(__method__))\n end",
"def get_header\n\theader = nil\n\tFile.open(\"./data/header.tex\",\"r\") do |f|\n\t\theader = f.readlines\n\tend\n\treturn header\n\t#パッケージの設定もここで入れれるといいんだが\nend",
"def com_dataset_file_path\n \"#{@tmp_dir}/#{@province.code}-8.geojson\"\n end",
"def get_country\n @single_city_data[\"sys\"][\"country\"]\n end",
"def create\n if @country\n @province = @country.provinces.build(params[:province])\n else\n @province = Province.new(params[:province])\n end\n\n respond_to do |format|\n if @province.save\n flash[:notice] = 'Province was successfully created.'\n format.html { redirect_to(context_url) }\n else\n format.html { render :action => \"new\" }\n end\n end\n end",
"def reg_prov_dataset_file_path\n \"#{@tmp_dir}/#{@province.reg.filename}-6.geojson\"\n end",
"def local_name(languages)\r\n ret = nil\r\n if languages\r\n lrs = languages.split(\",\")\r\n lrs.each do |lr|\r\n code = lr.split(\";\")[0]\r\n locale = locales.find(:first, :conditions => [\"code = ?\", code])\r\n ret = locale.name if locale\r\n break if ret\r\n end\r\n end\r\n ret || self.name\r\n end",
"def postalcode_matches_province?\n provinceHash = Hash.new\n provinceHash['NL'] = /A/i\n provinceHash['NS'] = /B/i\n provinceHash['PE'] = /C/i\n provinceHash['NB'] = /E/i\n provinceHash['QC'] = /G|H|J/i\n provinceHash['ON'] = /K|L|M|N|O|P/i\n provinceHash['MB'] = /R/i\n provinceHash['SK'] = /S/i\n provinceHash['AB'] = /T/i\n provinceHash['BC'] = /V/i\n provinceHash['NT'] = /X/i\n provinceHash['NU'] = /X/i\n provinceHash['YT'] = /Y/i\n (provinceHash[province] =~ postalcode) == 0\n end",
"def get_by_province\n\t\t\tdistricts = District.where(province_id: params[:province_id])\n\n\t\t\treturn render json: { status: 1 } if districts.blank?\n\n\t\t\trender json: {\n\t\t\t\tstatus: 0,\n\t\t\t\tresult: districts.map{ |district| { id: district.id, name: district.name } }\n\t\t\t}\n\t\tend",
"def test_identify_language_from_filename\n filename = 'one.fp'\n femp = Locale.new('femp', 'fp', 'fpt')\n curriculum.add(femp, %w(one two))\n assert_equal 'femp', curriculum.identify_language('femp.fp')\n end",
"def country_str(specimens)\r\n v = {} \r\n v[\"country not specified\"] = []\r\n specimens.each do |s|\r\n if !s.ce.blank? && !s.ce.geog.blank? && !s.ce.geog.country.blank? && !s.ce.geog.country.name.blank?\r\n if v[s.ce.geog.country.name].nil?\r\n v[s.ce.geog.country.name] = [s]\r\n else\r\n v[s.ce.geog.country.name] << s\r\n end\r\n else\r\n v[\"country not specified\"] << s\r\n end\r\n end\r\n v.delete(\"country not specified\") if v[\"country not specified\"].size == 0 \r\n is = []\r\n v.keys.sort.each do |c|\r\n txt = \"#{c.upcase}: \"\r\n txt << sex_str(v[c])\r\n txt += \". \"\r\n txt += inst_str(v[c]) + \".\"\r\n is << txt\r\n end\r\n is.join(\" \") \r\n end",
"def regional_code\n @regional_code ||= code_parts[1]\n end",
"def show\n @state_province = StateProvince.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @state_province }\n end\n end",
"def country_name(multilingual = false)\n if self.country\n country_data = ISO3166::Country[self.country]\n\t\t\tif country_data and multilingual\n\t\t\t country_data.translations[I18n.locale.to_s] || country_data.name\n\t\t\telsif country_data\n\t\t\t country_data.name\n\t\t\telse\n\t\t\t self.country\n\t\t\tend\n else\n \"\"\n end\n end",
"def cctld_from_locale( locale )\n # return \"il\" if locale.to_s == \"he\"\n return if locale.to_s.split( \"-\" ).size < 2\n\n region = locale.to_s.split( \"-\" ).last\n case region\n # There are a few exceptions to ISO 3166-1 / ccTLD mapping\n when \"gb\" then \"uk\"\n else region\n end\n end",
"def get_language_from_code code\n ISO_639.find(code).english_name if not(code.nil?)\n end",
"def polyglossia_default_language(language_code_3_chars)\n {\n 'ara' => 'arabic',\n 'frs' => 'farsi',\n 'kan' => 'kannada',\n 'mal' => 'malayalam',\n 'pun' => 'punjabi',\n }[language_code_3_chars]\n end",
"def prov_no_dataset_file_path\n \"#{@tmp_dir}/#{@province.code}-6_no.geojson\"\n end",
"def read_file\n\t\t\treturn 'wordlists/reverse_ip.txt'\n\t\tend",
"def get_lang_from_path\n case File.extname(@path).downcase\n when '.rb'\n 'ruby'\n when '.js'\n 'javascript'\n when '.php'\n 'php'\n else\n nil\n end\n end",
"def get_continent(country_doc)\n my_html = Nokogiri::HTML(country_doc)\n doc = my_html.at(\"table tr td div.region1 a\")\n region = nil\n if doc != nil then\n region = doc.text.to_s\n if str_include?(region, 'Asia')\n region = 'Asia'\n elsif str_include?(region, 'middle east')\n region = 'Asia'\n end\n end\n return region\n end",
"def read_platform_from_file(path:)\n path.basename.to_s.split('.').first\n end",
"def spanish_name\n self[5]\n end",
"def getRegion(elements)\n\n\n regionCode = elements[\"HouseFile/ProgramInformation/Weather/Region\"].attributes[\"code\"].to_i\n\n regionName = $ProvArr[regionCode-1]\n\n return regionName\nend",
"def update\n @province = Province.find(params[:id])\n\n respond_to do |format|\n if @province.update_attributes(params[:province])\n flash[:notice] = 'Province was successfully updated.'\n format.html { redirect_to(context_url) }\n else\n format.html { render :action => \"edit\" }\n end\n end\n end",
"def load_library(path)\n data = YAML.load_file(path)\n # maps the data to their proper language despcriptions\n data.map do |key, value|\n data[key] = { english: value[0], japanese: value[1] }\n end\n data\nend",
"def update\n @province = Province.find(params[:id])\n\n respond_to do |format|\n if @province.update_attributes(params[:province])\n format.html { redirect_to(@province, :notice => l(:notice_successful_update)) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @province.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def find_version\n if @language == :english\n ENGLISH\n elsif @language == :spanish\n SPANISH\n end\n end",
"def ruta_externa\n @base = \"http://www.gis3.com\"\n\n if I18n.locale == :es\n return @base + '/espanol'\n\n elsif I18n.locale == :en\n return @base + '/english'\n\n end\n\n end",
"def admin_province_params\n params.require(:province).permit(:pst, :gst, :hst)\n end",
"def create\n @hr_config_province = Hr::Config::Province.new(hr_config_province_params)\n\n respond_to do |format|\n if @hr_config_province.save\n format.html { redirect_to @hr_config_province, notice: 'បន្ថែមទទួលបានជោគ' }\n format.json { render :show, status: :created, location: @hr_config_province }\n else\n format.html { render :new }\n format.json { render json: @hr_config_province.errors, status: :unprocessable_entity }\n end\n end\n end",
"def state\n country = ISO3166::Country[country_residence]\n if country.try(:subdivisions?)\n country.subdivisions[state_code].try(:[], \"name\")\n else\n state_code\n end\n end",
"def get_country_name\n subdivision = Geonames::WebService.country_subdivision @latitude, @longitude\n subdivision.country_name\n end",
"def iso_file\n resource[:iso_file].first[\"name\"] if resource[:iso_file]\n end",
"def word1\n return ($en_cz == 'Y') ? @english : @czech\n end",
"def french_name\n self[4]\n end",
"def french_name\n self[4]\n end",
"def full_path_from_edict_file(filename=\"\")\n return Rails.root.join(\"data/cedict/#{filename}\").to_s\n end",
"def get_country_codes\n content = File.read(\"public/ssp/country_code.txt\")\n country_codes = Hash.new\n content.split(\":\").each do |country_code |\n cc = country_code.split(\",\")\n if cc.size == 2 \n country_codes[cc[0]] = cc[1]\n end\n end\n return country_codes\n end",
"def sector_description\n\t\tSECTOR_DESCRIPTIONS[sector.to_s]\n end",
"def sector_industry_label\n sector_name = industry.try(:sector).try(:name)\n industry_name = industry.try(:name)\n return \"\" unless industry_name && sector_name\n \"#{sector_name} / #{industry_name}\"\n end",
"def country\n @country ||= IsoCountryCodes.find(alpha2)\n end",
"def initialize file\n EasyTranslate.api_key = 'AIzaSyDrbD0AfKHiMZTYoite-ec4byLNlPxoX8k'\n @file = file\n @properties = {}\n \n File.open(file, \"r:UTF-8\").each do |line| \n if line.include? \":\"\n splited_line = line.encode!('UTF-8').strip.split(':')\n @properties[splited_line[0]] = splited_line[1] \n end \n end\n end",
"def reg_com_dataset_file_path\n \"#{@tmp_dir}/#{@province.reg.filename}-8.geojson\"\n end",
"def set_provinces\n @provinces = Province.all\n end",
"def getPopulationCity(code)\n @parse.map{ |airport| \n if( airport[\"population\"] == code) \n return airport[\"name\"]\n end\n }\n end",
"def index\n @hr_config_provinces = Hr::Config::Province.all\n end",
"def word2\n return ($en_cz == 'Y') ? @czech : @english\n end",
"def language\n fetch('nation.language')\n end",
"def compile_regional_dexes(path = \"PBS/regionaldexes.txt\")\r\n dex_lists = []\r\n section = nil\r\n pbCompilerEachPreppedLine(path) { |line, line_no|\r\n Graphics.update if line_no % 200 == 0\r\n if line[/^\\s*\\[\\s*(\\d+)\\s*\\]\\s*$/]\r\n section = $~[1].to_i\r\n if dex_lists[section]\r\n raise _INTL(\"Dex list number {1} is defined at least twice.\\r\\n{2}\", section, FileLineData.linereport)\r\n end\r\n dex_lists[section] = []\r\n pbSetWindowText(_INTL(\"Processing {1} section [{2}]\", FileLineData.file, section))\r\n else\r\n raise _INTL(\"Expected a section at the beginning of the file.\\r\\n{1}\", FileLineData.linereport) if !section\r\n species_list = line.split(\",\")\r\n for species in species_list\r\n next if !species || species.empty?\r\n s = parseSpecies(species)\r\n dex_lists[section].push(s)\r\n end\r\n end\r\n }\r\n # Check for duplicate species in a Regional Dex\r\n dex_lists.each_with_index do |list, index|\r\n unique_list = list.uniq\r\n next if list == unique_list\r\n list.each_with_index do |s, i|\r\n next if unique_list[i] == s\r\n raise _INTL(\"Dex list number {1} has species {2} listed twice.\\r\\n{3}\", index, s, FileLineData.linereport)\r\n end\r\n end\r\n # Save all data\r\n save_data(dex_lists, \"Data/regional_dexes.dat\")\r\n Graphics.update\r\n end",
"def detectLang(path)\n # The language detector is not doing well for subs, so we will just always assume english...\n return 'en'\n\n lang = $languageDetector.language_iso(getCleanText(path))\n if (lang != nil)\n return lang.to_s()\n end\n\n return UNKNOWN_LANG\nend"
] |
[
"0.6514513",
"0.62548363",
"0.6029765",
"0.5938827",
"0.5837015",
"0.5730205",
"0.5709851",
"0.5691844",
"0.5570934",
"0.551172",
"0.54329526",
"0.54239106",
"0.53504586",
"0.5322867",
"0.5319085",
"0.5305472",
"0.53042424",
"0.52975625",
"0.52730817",
"0.5267117",
"0.52643603",
"0.52411705",
"0.5215517",
"0.5212591",
"0.51779777",
"0.5165768",
"0.5155419",
"0.51456815",
"0.5103798",
"0.50619006",
"0.50440174",
"0.5031175",
"0.50054955",
"0.49553218",
"0.49544945",
"0.49409702",
"0.49118838",
"0.49107194",
"0.49096337",
"0.48957264",
"0.4870542",
"0.48611864",
"0.48518232",
"0.48434865",
"0.4840702",
"0.48330852",
"0.4828863",
"0.48214167",
"0.48090228",
"0.48000076",
"0.4797722",
"0.4794526",
"0.47824052",
"0.4773133",
"0.47538438",
"0.4753278",
"0.47488207",
"0.47343063",
"0.47176334",
"0.46916178",
"0.46738923",
"0.46599823",
"0.46418878",
"0.4627335",
"0.46261257",
"0.46166685",
"0.46157005",
"0.46149528",
"0.4609471",
"0.46034142",
"0.46007097",
"0.45978034",
"0.4592331",
"0.45909753",
"0.45857146",
"0.45760188",
"0.45690903",
"0.45629802",
"0.45578519",
"0.45533338",
"0.45423946",
"0.45409423",
"0.45360866",
"0.45343807",
"0.4531169",
"0.4531169",
"0.45287696",
"0.45162115",
"0.45155796",
"0.45112377",
"0.4506429",
"0.450041",
"0.44953215",
"0.44938356",
"0.4491356",
"0.44905168",
"0.44837967",
"0.44814828",
"0.44795328",
"0.4472738"
] |
0.64560485
|
1
|
Returns the service company that performed the log acquisition Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.service_company => "ANY LOGGING COMPANY LTD."
|
def service_company
self.well_info.service_company
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def company\n @company ||= research_param(:company) || company_list.first\n end",
"def name\n latest_ccla_signature.company\n end",
"def company_name\n self.dig_for_string(\"agentSummary\", \"office\", \"companyName\")\n end",
"def getcompany\n Company.company_than(need_calc_company)\n end",
"def company\n alliance_company\n end",
"def user_company\n if Client.find_by_id(current_user.client_id)\n Client.find_by_id(current_user.client_id).client_name\n end\n end",
"def company_name\n @company_name\n end",
"def company\n @attributes[:company]\n end",
"def company_name\n @company_name\n end",
"def company_name\n object.company.name\n end",
"def company_name\n self.well_info.company_name\n end",
"def company_name\t\t\t# Getter method - return nil if name is not found\n\t\tcompany.try(:name)\n\tend",
"def current_company_name\n begin\n Client.find(current_subdomain).webname\n rescue\n \"\"\n end\n end",
"def company_name\n account.name if account\n end",
"def get_company\n @company ||= current_company\n end",
"def current_company\n Company.find(1)\n end",
"def company_name\n element_with_value('CompanyName', opts[:company_name][0..34])\n end",
"def to_s\n company\n end",
"def company_name\n quote.name\n end",
"def identificacion_company\n \"#{type_identification}-#{rif}\"\n end",
"def get_Company(name=nil)\n\n getElement_text(\"cust_vendors\").click\n\n getElement_text(\"Customers\").click\n\n if(name!=nil)\n getElement_text_direct(name).click\n else\n getElement_text(\"company_name_data\").click\n end\n end",
"def current_company\n Company.find(:first)\nend",
"def call_company_service\n ch_api = CompaniesHouseApi.new\n response = ch_api.company company_number\n parse_response response\n end",
"def company_name\n element_with_value('CompanyName', opts[:company_name])\n end",
"def thorins_company; end",
"def describe_company(company)\n signed_get(COMPANIES_PATH, escape(company))\n end",
"def company_id\n self.dig_for_string(\"agentSummary\", \"office\", \"companyId\")\n end",
"def company\n @company ||= Harvest::API::Company.new(credentials)\n end",
"def service_name\n @documents.service_name\n end",
"def company; end",
"def company; end",
"def lookup(company)\n cfpb_name = fuzzy_cfpb_lookup(company).first || {}\n iex_name = match_cfpb_to_iex(cfpb_name) || {}\n\n { cfpb: cfpb_name['name'], iex: iex_name['name'] }\n end",
"def company_name\n self.companies.count > 0 ? self.companies.first.title : ''\n end",
"def company_name\n Faker::Company.name\n end",
"def company_name\n Faker::Company.name\n end",
"def main_co\n companies.main.first \n end",
"def service_name\n return @service_name\n end",
"def company_id\n if @company.respond_to?(:to_hash)\n @company.fetch(:company_id) { @company }\n elsif @company.respond_to?(:company_id)\n @company.company_id\n else\n @company\n end\n end",
"def company_code\n if self.yard.present? && self.yard.facility.present? && self.yard.facility.country.present?\n country = self.yard.facility.country\n \"COPART#{country.code}\".upcase\n else\n \"\"\n end\n end",
"def service_name; end",
"def name\n company.blank? ? full_name : \"#{company} (#{full_name})\"\n end",
"def current_company\n current_user ? current_user.company : nil\n end",
"def company_info\n company_info ||= CompanyLeave.for_company(company).first\n end",
"def company\n @company ||= Company.find(params[:id])\n end",
"def company\n response = JSON.parse(@client.get(\"users/#{send(:id)}/companies\").body)\n Promisepay::Company.new(@client, response['companies'])\n rescue Promisepay::NotFound\n nil\n end",
"def current_company() # :doc:\n current_user.full?(&:company)\n end",
"def company_name(company_name, direction = :push)\n if direction == :push\n company_name[0..82]\n else\n company_name\n end\n end",
"def pull_company(cfpb, iex)\n # Start with CFPB because it is way more brittle\n complaint = CFPBService.search_complaints cfpb\n stock = IEXService.search_stocks iex\n\n {\n cfpb_complaint_count: complaint[:complaint_count],\n cfpb_random_complaint: complaint[:comment],\n iex: stock\n }\n end",
"def search_for_company(search, cookies)\n companies = []\n search = search.gsub(/ /, '+')\n searchpage = '/FreeTextSearch.xhtml?opCode=search&autoSuggested=true&freeText='\n result = request_page(\"#{searchpage}#{search}\", cookies)\n if result.body.include?('Contacts at this Company')\n id = result.body.split('id=\"companyGuid\" name=\"companyGuid\" value=\"')[1].split('\"')[0].to_i\n elsif result.body.include?('Contacts Search Results')\n return parse_multiple_search_results_employee(result)\n elsif result.body.include?('did not match any results')\n return nil\n elsif result['Location']\n id = result['Location'].split('/')[5].to_i\n else\n return parse_multiple_search_results(result)\n end\n return id\nend",
"def get_company_info(link)\n info = {}\n company_page = parse_page(@agent.get(link))\n info[:title] = get_job_title(company_page)\n info[:company] = get_company(company_page)\n info[:location] = get_location(company_page)\n info[:date] = get_date(company_page)\n info[:company_id] = get_company_id(company_page)\n info[:position_id] = get_position_id(company_page)\n info\n end",
"def core \n self.service.organization\n end",
"def customer_name\n company.blank? ? full_name : \"#{company} (#{full_name})\"\n end",
"def customer_name\n company.blank? ? full_name : \"#{company} (#{full_name})\"\n end",
"def company_information(params)\n get('company-information',params)\n end",
"def current_company\n @current_company = current_user.company\n end",
"def name\n self.company.name unless company.nil?\n end",
"def sic_code\n fetch('company.sic_code')\n end",
"def company_number\n 1\n end",
"def company\n if teacher? || !self.group\n return nil\n else\n self.group.company\n end\n end",
"def task_name_company\n [executor.try(:profile).try(:first_name), executor.try(:profile).try(:last_name), executor.try(:profile).try(:company)].join(' ')\n end",
"def task_name_company\n [executor.try(:profile).try(:first_name), executor.try(:profile).try(:last_name), executor.try(:profile).try(:company)].join(' ')\n end",
"def current_company_curr\n Currency.where('client_id = ? and default_currency = ?', current_subdomain, \"t\").first.try(:currency_symbol)\n end",
"def cloud_service_name\n return @cloud_service_name\n end",
"def set_companies_service\n @service = Service.where(company_id: @current_company.id).find(params[:id])\n end",
"def account_name\n return company.company_name unless company.nil? || company.company_name.nil?\n\n [forename, surname].join(' ')\n end",
"def other_party(company)\n (company == service_provider) ? service_buyer : service_provider\n end",
"def set_service_company\n @service_company = ServiceCompany.find(params[:id])\n end",
"def service_name\n @service_name ||= InchCI::ProjectUID.new(uid).service\n end",
"def suffix\n fetch('company.suffix')\n end",
"def hca_branch_of_service\n HCA_SERVICE_BRANCHES[branch_of_service_code] || 'other'\n end",
"def xlate_service()\n return SERVICE_XLATES[@service] if (SERVICE_XLATES.has_key?(@service))\n return(@service.to_s) \n end",
"def name\n company.blank? ? full_name : \"#{company} (#{full_name})\"\n end",
"def type\n fetch('company.type')\n end",
"def name\n \"#{id}-#{company_name}\"\n end",
"def provision_company\n @attributes[:provision_company]\n end",
"def current_company\n if current_user.company_users != []\n session[:company_id] ||= current_user.company_users.first.company.id\n @current_company ||= Company.find(session[:company_id])\n else\n @current_company = nil\n end\n end",
"def need_calc_company\n company_ids = []\n company_ids = self[:company].split(\",\") unless self[:company].blank?\n company_ids\n end",
"def service_name\n return @target.service_name\n end",
"def app_company\n 'BarkerEST'\n end",
"def find_company\n Company.find(params[:company_id].to_i)\n end",
"def current_login\n current_company ? current_company : current_user.company\n end",
"def company=(v)\n Axlsx.validate_string v\n @company = v\n end",
"def _display_name\n respond_to?(:service_name) ? service_name : name.split(\"::\").last\n end",
"def get_company_info_from_fullcontact\n response = HTTParty.get(FULLCONTACT_LOOKUP_API, query: { \"domain\" => fetched_domain,\n \"apiKey\" => FULLCONTACT_API_KEY })\n response = response.success? ? JSON(response.body) : raise(\"Could not get information from FullContact, check rate limit.\")\n raise \"FullContact retry error\" if response[\"status\"] == 202 # FullContact queues for search sometimes.\n response\n end",
"def guess_company_domain\n if self.company_domain.blank?\n string = self.company_name.to_s.downcase.gsub(' ', '') + \".fr\"\n self.company_domain = string\n end\n end",
"def company_brand_code\n self.dig_for_string(\"agentSummary\", \"office\", \"brandCode\")\n end",
"def company_name\n name.left_name\nend",
"def company_params\n params[:company]\n end",
"def company_params\n params[:company]\n end",
"def company_info(company_id, *fields)\n get(\"/organizations/#{company_id}#{field_selector(fields)}\")\n end",
"def get_grand_company(page)\n gc = nil\n lines = page.grep(/txt_name/)\n\n # checks to see if the optional free company line has been added\n fc = lines.grep(/a href=/)\n\n # GOOD CONDITIONS\n # 5 lines, guarentees they're in a GC\n # 4 lines if they're NOT in an FC, otherwise the 4th line is FC\n if lines.length < 4 || (lines.length == 4 && ! fc.empty?)\n return gc\n else\n # Make name of grand company the beginning of the line\n line = lines[3][25..-1]\n # Get the name on it's own\n line = line.split('/')\n gc = line[0]\n end\n end",
"def get_grand_company(page)\n gc = nil\n lines = page.grep(/txt_name/)\n\n # checks to see if the optional free company line has been added\n fc = lines.grep(/a href=/)\n\n # GOOD CONDITIONS\n # 5 lines, guarentees they're in a GC\n # 4 lines if they're NOT in an FC, otherwise the 4th line is FC\n if lines.length < 4 || (lines.length == 4 && ! fc.empty?)\n return gc\n else\n # Make name of grand company the beginning of the line\n line = lines[3][25..-1]\n # Get the name on it's own\n line = line.split('/')\n gc = line[0]\n end\n end",
"def service; services.first; end",
"def translate_company_args hash\n handle_company_auto_add hash, :wikirate_company, :auto_add_company\n\n hash[:company] = hash.delete :wikirate_company\n end",
"def domain\n settings.service.domain \n end",
"def service_name\n self[:name].gsub(/\\.|,/, '_').gsub(/\\s/, '').underscore.to_sym if self[:name]\n end",
"def search\n return nil unless valid?(:search)\n\n success = call_company_service\n errors.add(:company_number, :no_company_search_results) if success && !company_name?\n success\n end",
"def branch_of_service\n SERVICE_BRANCHES[branch_of_service_code]\n end",
"def service_display_name(arg)\n service = arg.to_sym if arg.respond_to?(:to_sym)\n service = service_name(arg) unless @options.include?(service)\n if service.nil?\n nil\n else\n @options[service].display_name\n end\n end",
"def billing_name\n company.blank? ? full_name : \"#{full_name} (#{company})\"\n end"
] |
[
"0.6822279",
"0.6714972",
"0.67119133",
"0.67011994",
"0.6520701",
"0.643856",
"0.64375067",
"0.639938",
"0.6284502",
"0.6275567",
"0.6275199",
"0.62654847",
"0.62477225",
"0.61418927",
"0.61036944",
"0.6094983",
"0.6093869",
"0.603673",
"0.60061926",
"0.59661937",
"0.59497607",
"0.5897618",
"0.5887766",
"0.5883166",
"0.5879124",
"0.5871442",
"0.5831064",
"0.5827794",
"0.5826731",
"0.5810336",
"0.5810336",
"0.5757079",
"0.5720909",
"0.5720695",
"0.5720695",
"0.57205796",
"0.5714532",
"0.57117003",
"0.5694368",
"0.5678412",
"0.5677519",
"0.56706494",
"0.5652879",
"0.5630082",
"0.5621018",
"0.5620114",
"0.56026644",
"0.55962265",
"0.5575579",
"0.5556301",
"0.5556194",
"0.5547092",
"0.5547092",
"0.55314463",
"0.55265564",
"0.55156225",
"0.5514513",
"0.5499092",
"0.5495734",
"0.54875255",
"0.54875255",
"0.5484431",
"0.5480253",
"0.54736733",
"0.54611206",
"0.54519695",
"0.5446601",
"0.5445531",
"0.5444887",
"0.54406136",
"0.5416658",
"0.54110044",
"0.5400115",
"0.53927404",
"0.5392645",
"0.5385078",
"0.537377",
"0.53714615",
"0.5347853",
"0.53441644",
"0.53338456",
"0.5304414",
"0.5299128",
"0.5278231",
"0.5269948",
"0.52669793",
"0.525283",
"0.5246634",
"0.5246634",
"0.5233092",
"0.52252036",
"0.52252036",
"0.52216077",
"0.5219738",
"0.52123594",
"0.5206302",
"0.51923895",
"0.5186814",
"0.5186258",
"0.51693827"
] |
0.73509735
|
0
|
Returns a String with the date described in the file. Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.log_date => "25DEC1988"
|
def log_date
self.well_info.date_logged
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def date\n tt = Time.gm(*filename_base.scan(/\\d+/))\n\n def tt.to_s\n to_formatted_s(:short_date_with_year) + \" \" + to_formatted_s(:short_time)\n end\n\n tt\n\tend",
"def date\n file.version.authored_date.strftime(\"%B %d, %Y\")\n end",
"def GetDateOfFile ( fl )\n dt = parse_date(fl)\n return ( dt.getlocal().strftime(\"%B %d, %Y at %I:%M %p %Z\"));\nend",
"def to_s\n @file.to_s.scan(%r{(\\d{4})(\\d{2})(\\d{2})(.*?)-(.*?)\\..*}) do |year,month,day,time,name|\n return \"#{year}/#{month}/#{day}/#{name}\"\n end\n end",
"def data_file(date)\n File.expand_path(File.join(@config[:data_dir], date.strftime(\"%Y-%m-%d.espi\")))\n end",
"def file_name_date_to_date(record,row)\n #rintraccio il file\n file = ImportFile.find(session[:file_id])\n #campagna 199X\n camp90 = /([9])(\\d)\\D+\\d+[.]\\S*/\n #campagna 20XX in avanti\n camp00 = /(\\d+)\\D+\\d+[.]\\S*/\n #se il file si riferisce alle campagne dal 1990 al 1999\n if file.file_name =~ camp90\n #anno = 19 + numeri rimanenti\n anno = \"19\" + $1 + $2\n #se il file si riferisce alle campagne dal 2000 al 2099\n elsif file.file_name =~ camp00\n #anno = 20 + numeri rimanenti\n anno = \"20\" + $1\n end\n #memorizzo temporaneamente la data per poterci lavorare sopra\n data_temp = Copl.new\n data_temp.data = record.data\n #a meno che l'anno della data del record non corrisponda a quello del nome del file\n unless data_temp.data.year == anno.to_i\n #salvo l'errore\n save_error(record,\"File name - Data\",row)\n #segnalo che c'è stato un errore sulla riga\n session[:row_error] = true\n #e segnalo l'errore sul file\n session[:file_error] = true\n end\n end",
"def log_filename\n date_str = `date +%d%b%Y`[0..-2]\n LOG_DIR + \"Log#{date_str}.log\"\nend",
"def date_str d\n Util::date(d)\n end",
"def getLogDate()\n return self.getDateStr()\n end",
"def read_date; end",
"def read_date=(_); end",
"def getFullLogDate()\n return self.getDateStr.to_FullLogDate()\n end",
"def date\n \"#{self[:day]}_#{self[:month]}_#{self[:year]}\"\n end",
"def to_filename\n \"#{year}#{sprintf(\"%02d\", month)}#{sprintf(\"%02d\", day)}-\" +\n \"#{sprintf(\"%02d\", hour)}_#{sprintf(\"%02d\", min)}_#{sprintf(\"%02d\", sec)}\"\n end",
"def date\n \"#{day} #{month.capitalize} #{year}\"\n end",
"def archive_file_suffix\n case @roll_period\n when :weekly\n @file_date.strftime(\"week-of-%Y-%m-%d\").to_s\n when :monthly\n @file_date.strftime(\"%Y-%m\").to_s\n else\n @file_date.strftime(\"%Y-%m-%d\").to_s\n end\n end",
"def read_pic_date(filename)\n date = read_pic_edate(filename) \n if date == nil \n date = read_pic_fdate(filename) \n end\n return date\nend",
"def get_log_time(line)\n data_string = line.match(/[\\w]*[\\s]*[\\w]*[\\s]*[^\\s]*/)[0]\n # the year is not included, so this will fail if the current year is different\n # for now we'll hack it to be the current year\n date = DateTime.parse(\"#{data_string} #{REPORT_YEAR}\")\nend",
"def get_date(date)\n\t\tif date != nil\n\t\t\ttemp = Date.parse date.to_s\n\t\t\treturn temp.strftime(\"%a, %b %d %Y\")\n\t\telse\n\t\t\treturn \"Not specifed\"\n\t\tend\n\tend",
"def ndvi_file_to_date (s) \n\t#MT3RG_2007_50-56_250m_composite_ndvi.rgb.jpg\n\t bits = s.split(\"_\")\n\t start_day = bits[2].split(\"-\").first\n\treturn(Time.gm(bits[1].to_i, 1,1,0,0,0) + start_day.to_i * 24*60*60)\nend",
"def file_name\n \"#{dir}/CAZ-#{Date.current.iso8601}-ABCDE.csv\"\n end",
"def date\n dreport.date_format\n end",
"def svn_date(a_time)\n a_time.strftime(\"%Y-%m-%d\")\nend",
"def date\n data[\"date\"] ||= (draft? ? source_file_mtime : site.time)\n end",
"def log_file_name\n\t\tdt = Time.now\n\n\t\tdstr = sprintf(\"%.4d%.2d%.2d\", dt.year, dt.mon, dt.mday)\n\t\trhost = (tunnel_peer || 'unknown').split(':')[0]\n\n\t\t\"#{dstr}_#{rhost}_#{type}\"\n\tend",
"def log_file_name\n\t\tdt = Time.now\n\n\t\tdstr = sprintf(\"%.4d%.2d%.2d\", dt.year, dt.mon, dt.mday)\n\t\trhost = (tunnel_peer || 'unknown').split(':')[0]\n\n\t\t\"#{dstr}_#{rhost}_#{type}\"\n\tend",
"def published_at_from_filename\n basename.to_s =~ PUBLISHED_AT_PATTERN\n Date.parse($1) rescue nil\n end",
"def get_report_date(folder)\r\n\tlast_day = Time.parse('2011-01-01')\r\n\tDir[\"#{folder}/*.pdf\"].each do |pdf|\r\n#puts pdf\r\n\t\tfilename = File.basename(pdf).gsub('.pdf', '')\r\n\t\tfs = filename.split(' ')\r\n\t\tstore_name = fs[0]\r\n\t\tdt = fs[-1]\r\n\t\tdt.gsub!('W', '')\r\n\t\tdt.gsub!('M', '')\r\n#puts dt\r\n\t\tdt = Time.parse(dt)\r\n\t\tlast_day = dt if last_day < dt\r\n\tend\r\n\r\n\tdate = last_day.strftime('%Y-%m-%d')\r\n\r\n\treturn date\r\nend",
"def print_date\n\t$report_file.puts \"Today's Date: #{DateTime.now.strftime('%m/%d/%Y')}\"\nend",
"def build_date\n Time.at(@header.build_date).to_datetime\n end",
"def get_language_filename( source, use_locale = false )\n before_substring = source.slice(0,(source.rindex(\".\") ))\n after_substring = source.slice(source.rindex(\".\"), (source.size - before_substring.size) )\n if use_locale\n return \"#{before_substring}-#{GettextLocalize.locale.to_s}#{after_substring}\"\n else\n return \"#{before_substring}-#{GettextLocalize.locale.to_s[0,2]}#{after_substring}\"\n end\n end",
"def date_str\n date.strftime(\"%Y%m%d\")\n end",
"def web_date; strftime(WEB_DATE_FORMAT); end",
"def dncDate(dnc)\n if dnc.date == nil\n \"\"\n else\n dnc.date.strftime(\"%m/%d/%y\")\n end\n end",
"def zt_date date\n if date.year == Time.now.year\n l date, format: :short\n else\n l date, format: :long\n end\n end",
"def get_1904\n @date_1904\n end",
"def file_name\n ts = @entries.first.time_stamp\n File.join(@coord.options.output_dir,\n ts.strftime('%Y-%m-%d'),\n ts.strftime('%H-%M'),\n ts.strftime('%S.%3N-') + id)\n end",
"def date\n return @_date if @_date\n\n frontmatter_date = data['date']\n\n # First get the date from frontmatter\n @_date = if frontmatter_date.is_a? Time\n frontmatter_date.in_time_zone\n else\n Time.zone.parse(frontmatter_date.to_s)\n end\n\n # Next figure out the date from the filename\n source_vars = blog_data.source_template.variables\n\n if source_vars.include?('year') &&\n source_vars.include?('month') &&\n source_vars.include?('day')\n\n filename_date = Time.zone.local(path_part('year').to_i, path_part('month').to_i, path_part('day').to_i)\n if @_date\n raise \"The date in #{path}'s filename doesn't match the date in its frontmatter\" unless @_date.to_date == filename_date.to_date\n else\n @_date = filename_date.to_time.in_time_zone\n end\n\n end\n\n raise \"Blog post #{path} needs a date in its filename or frontmatter\" unless @_date\n\n @_date\n end",
"def behandlungsdatum_str\n\t\t@behandlungsdatum_str || fmt_date( self.behandlungsdatum )\n\tend",
"def get_time(infile)\n DateTime.strptime(File.basename(infile).split('.')[1, 2].join('.') + '+0', '%y%j.%H%M%z')\n end",
"def getDateStr\n return \"\" if @line.length < 15\n tmpStr = @line[0..14]\n begin\n DateTime.strptime(tmpStr, \"%b %d %H:%M:%S\")\n out = tmpStr\n rescue\n out = \"\"\n end\n return out \n end",
"def filename\n current_time = Time.new\n formatted_current_time = current_time.strftime(\"%Y%m%d_%H%M%S\")\n formatted_current_time + \"_\" + original_filename\n end",
"def filename\n current_time = Time.new\n formatted_current_time = current_time.strftime(\"%Y%m%d_%H%M%S\")\n formatted_current_time + \"_\" + original_filename\n end",
"def read_pic_edate(filename)\n date = EXIFR::JPEG.new(filename).date_time\nend",
"def ltf\n strftime(LOG_TIME_FORMAT)\n end",
"def ltf\n strftime(LOG_TIME_FORMAT)\n end",
"def date\n @date ||= Time.utc(*Gem.source_date_epoch.utc.to_a[3..5].reverse)\n end",
"def get_processed_filename\n # We can make this if statement a single line, but then it'd be too long.\n filename = if file_options.nil? || file_options[:name].blank?\n name + '.csv'\n else\n file_options[:name]\n end\n if filename =~ /\\Ay#/\n date = Date.today.advance(days: -1)\n return date.strftime(filename[2..-1])\n else\n date = Date.today\n return date.strftime(filename)\n end\n end",
"def file_path\n \"#{Time.now.to_f}.#{filename}\"\n end",
"def date1904() @@date1904; end",
"def date_at(event)\n f = path event\n return nil unless File.size? f\n DateTime.parse File.read(f)\n end",
"def extract_day_mth_yr(given_date)\n\ttmp_new_date = given_date.split('/')\n\t# Get the current month\n\tset_cur_mth(tmp_new_date[0])\n\t# Get the current day\n\tset_cur_day(tmp_new_date[1])\n\t# Get the current year\n\tset_cur_year(tmp_new_date[2])\n\t# Get the body of the output filename\n\t$op_file_body = \"_\"+ month_num_to_ver(get_cur_mth) +\"_\"+ get_cur_day.to_s + \"_\" + get_cur_year.to_s\n\t# Get the name of the output filename\n\t$op_filename = $op_file_prefix + $op_file_body + $op_file_suffix\nend",
"def write_date(filename, date)\n begin\n filehandle = File.open(filename, \"w\")\n filehandle.write(date) \n rescue IOError => e\n \"Can't write into log file!\"\n ensure\n filehandle.close unless filehandle == nil\n end\n end",
"def easy_date; date; end",
"def formal_publication_date\n publication_date.to_s(:formal_wo_ordinal)\n end",
"def filename\n\t\t\"%s/data/RFCs/rfc%d.txt\" % [ RAILS_ROOT, number ]\n\tend",
"def to_s\n \"File #{file_identity.inspect} (version #{version}) \" \\\n \"at #{extracted_at.strftime('%Y-%m-%d %H:%M')}. \" \\\n \"#{full? ? 'A full' : 'An update'} extract \" \\\n \"for #{start_date} to #{end_date}.\"\n end",
"def human_readable_date\n d = self.date\n d.strftime(\"%B %d, %Y\")\n end",
"def ltf\n strftime(LOG_TIME_FORMAT)\n end",
"def last_entry(cve_name, ext, before_date=nil)\n path = self._entry_path(cve_name)\n\n d=nil\n d=Date.parse(before_date) rescue nil unless before_date.nil?\n\n dates=[]\n # get dates of current files\n Dir[\"#{path}/2*.#{ext}\"].each { |ipath|\n begin\n file_date_str = ipath.split('/').last.split('.').first\n file_date = Date.parse(file_date_str)\n dates << file_date if d.nil? || file_date < d\n end\n }\n\n return nil if dates.length == 0\n\n dates.sort\n\n filepath=File.join(path, \"#{dates.last.to_s}.#{ext}\")\n\n return nil unless File.exist? (filepath)\n str = nil\n begin\n File.open(filepath) { |f| str = f.read }\n end\n str\n end",
"def as_readable_date\n strftime \"%b %e, %Y\"\n end",
"def genfilename(ext, time = Time.now)\n time.strftime(\"%Y-%m-%d\") + ext\n end",
"def read_pic_fdate(filename)\n date = File.mtime(filename)\nend",
"def do_getCivetScanDate(keyname:, modality:, scanDate:, settings:, opt:)\n #\n # craft the fullpath filename of the *civet_scan_id* file\n filename = 'civet_scan_id.txt'\n subdir_name = modality + '-' + scanDate\n filename_fullpath = File.join(settings['LORIS_ROOT_DIR'], keyname, subdir_name, filename)\n puts filename_fullpath\n\n if ( !File.exists?(filename_fullpath) || !File.file?(filename_fullpath) ) then\n puts sprintf('Warning: do_getCivetScanDate(): Passed Civet Id file does not exist: %s\\n', filename_fullpath)\n return false\n end\n \n # open, read, split, close, return civetScanDate\n civet_id_file_h = File.open(filename_fullpath)\n civet_id_string = civet_id_file_h.read()\n\n # split: gotta have 2 parts, with '-' separator\n civet_id_string_parts = civet_id_string.split('-')\n if ( civet_id_string_parts.length != 2 ) then\n puts sprintf('Warning: do_getCivetScanDate(): Invalid Civet Id string found in file: %s\\n', filename_fullpath)\n return false\n end\n\n keyname = civet_id_string_parts[0]\n civetScanDate = civet_id_string_parts[1].strip\n civet_id_file_h.close()\n return civetScanDate\nend",
"def get_revdate(doc_path)\n doc = Nokogiri::HTML(File.open(doc_path)) { |config| config.strict.nonet}\n revdate = doc.search('//span[@id=\"revdate\"]').text.strip\n DateTime.strptime(revdate, '%Y-%m-%d') if /^\\d{4}-\\d{2}-\\d{2}$/.match(revdate)\nend",
"def date; end",
"def date; end",
"def date; end",
"def date; end",
"def todays_data_file_name\n \"/tmp/#{environment.to_s}_Afip_#{ Afip.cuit }_#{ Time.new.strftime('%Y_%m_%d') }.yml\"\n end",
"def production_date(*options)\n return (@check_level_details[:is_correspondent] ? @batch.date.strftime(\"%Y%m%d\") : @check.check_date.strftime(\"%Y%m%d\"))\n end",
"def www_date(date)\r\n if date.nil?\r\n Time.now.strftime('%d/%m/%Y')\r\n else\r\n date.strftime('%d/%m/%Y')\r\n end\r\n end",
"def datum\nt = Time.now\ndate = t.strftime(\"%y%m%d\")\nend",
"def readable_date\n date.strftime(\"%B %d, %Y\")\n end",
"def ref_number\n if ['AHN', 'SUBURBAN HEALTH', 'UWL', 'ANTHEM'].include?(@facility_name)\n file_number = @batch.file_name.split('_')[0][3..-1] rescue \"0\"\n date = @batch.date.strftime(\"%Y%m%d\")\n \"#{date}_#{file_number}\"\n else\n (@batch.batchid.include?(\"AH\") ? @batch.batchid : @batch.date.strftime(\"%Y%m%d\"))\n end\n end",
"def formatted_date(date = nil)\n return '' unless date\n date.last_modified_date.strftime(\"%m/%d/%y\")\n end",
"def lunar_date(year, month, day)\n l = yang_to_nong(year, month, day)\n l[0].to_s + '-' + l[1].to_s + '-' + (/^\\d+/.match(l[2].to_s)).to_s\n end",
"def date\n get_scm_data if @_date.nil?\n @_date\n end",
"def strf_date(date_time)\n begin\n date_time.strftime('%Y-%m-%d')\n rescue\n date_time\n end\n end",
"def date \n\t\tI18n.l(moment, format: :date_long)\n\tend",
"def return_date\n\t\tif(last_line_modified_date && last_modified_date != nil)\n\t\t\tif(last_line_modified_date <= last_modified_date)\n\t\t\t\treturn last_line_modified_date()\n\t\t\telse\n\t\t\t\treturn last_modified_date()\n\t\t\tend\n\t\telse\n\t\t\treturn '2000-01-01'\n\t\tend\n\tend",
"def git_date2txt( datestring)\n # Date: Mon Aug 2 14:39:56 2021 +0100\n # assume we dont care about seconds, tz or year most of time.\n wd,month,day,time,year = datestring.split\n return sprintf \"%02d-%3s %s\", day, month, time[0,5]\nend",
"def DateFormat(date)\n @newDate = date[:month] + \"/\" + date[:day] + \"/\" + date[:year]\n return @newDate\n end",
"def date\n @date ||= @config['date']\n end",
"def file_datetime\n @file_datetime\n end",
"def view_date(str)\r\n\t\t(wday,day,mon,year,hhmmss,etc) = str.to_s.split(/ /)\r\n\t\tmonth = @months[mon]\r\n\t\tstr = \"#{year}\\/#{month}\\/#{day} #{hhmmss}\"\r\n\t\treturn str\r\n\tend",
"def to_s\n report_date.strftime(\"%B %Y\")\n end",
"def read_date(taglib, **opts)\n v10_year = taglib.id3v1_tag.year.to_s if taglib.id3v1_tag.year > 0\n v24_date = read_first_tag(taglib, ['TDRC'])\n\n # check variables in order of importance\n date_str = v24_date || v10_year\n puts \"MP3#date: date_str = \\\"#{date_str}\\\"\" if $DEBUG\n\n date_str\n end",
"def httpdate\n return \"#{self.day_name[0, 3]}, #{@t_day} #{self.month_name[0, 3]} #{@t_year} #{\"%02d\" % @t_hour}:#{\"%02d\" % @t_min}:#{\"%02d\" % @t_sec} GMT\"\n end",
"def pdf_file_name\n \"#{Payment.model_name.human}_#{I18n.l(object.created_at, format: '%Y%m%d%-k%M')}\"\n end",
"def day_to_directory\n Date.strptime(DateTime.now.to_s, '%Y-%m-%d').to_s\n end",
"def filepath(root=ROOT)\n File.expand_path(Time.now.strftime(\"#{root}/%Y/%m%B.sql\"))\n end",
"def file\n @pathname.to_s\n end",
"def file_name\n\t\treturn 'st' + student_id.to_s + 'pr' + problem_id.to_s + 'so' + id.to_s\n\tend",
"def date\n return @date if @date\n\n return Time.at(ENV['SOURCE_DATE_EPOCH'].to_i).gmtime if ENV['SOURCE_DATE_EPOCH']\n\n return File.mtime(path) if File.exist?(path)\n\n Time.now\n end",
"def experiment_filename\n date = DateTime.now.strftime('%Y-%m-%d')\n \"#{date}_Job_#{job.id}\"\n end",
"def get_log_basename( data_import_session )\n datafile_base_name = File.basename( data_import_session.file_name ).to_s\n .remove( File.extname( data_import_session.file_name ).to_s )\n \"#{ get_iso_timestamp(data_import_session) }#{ Rails.env == 'development' ? 'prod' : 'dev' }_#{ datafile_base_name }\"\n end",
"def show_header_date\n I18n.localize(Date.today, format: :long)\n end",
"def got_enrolled_on\n\n begin\n # Get full month name, non-zero-padded date, and full year\n formatted_date = Date.strptime(enrollment_date, \"%m-%d-%Y\").strftime(\"%B %-d %Y\")\n enrollment_string = name + \" - \" + formatted_date\n rescue ArgumentError\n enrollment_string = \"Invalid Date\"\n end\n\n return enrollment_string\n\n end",
"def log_file(log_path = nil)\n # Get hostname\n host = session.sys.config.sysinfo[\"Computer\"]\n\n # Create Filename info to be appended to downloaded files\n filenameinfo = \"_\" + ::Time.now.strftime(\"%Y%m%d.%M%S\")\n\n # Create a directory for the logs\n logs = if log_path\n ::File.join(log_path, 'logs', 'persistence', Rex::FileUtils.clean_path(host + filenameinfo))\n else\n ::File.join(Msf::Config.log_directory, 'persistence', Rex::FileUtils.clean_path(host + filenameinfo))\n end\n\n # Create the log directory\n ::FileUtils.mkdir_p(logs)\n\n # logfile name\n logfile = logs + ::File::Separator + Rex::FileUtils.clean_path(host + filenameinfo) + \".rc\"\n logfile\n end"
] |
[
"0.64819264",
"0.62180805",
"0.6192347",
"0.614532",
"0.5927823",
"0.5828196",
"0.58037513",
"0.5778604",
"0.57598037",
"0.57458884",
"0.56466603",
"0.56174666",
"0.5538115",
"0.55343956",
"0.55294913",
"0.5510369",
"0.5505074",
"0.5493487",
"0.54882306",
"0.54448825",
"0.5406226",
"0.5396355",
"0.5379041",
"0.5374047",
"0.53476524",
"0.53476524",
"0.5342616",
"0.5332973",
"0.53301543",
"0.5313975",
"0.5311042",
"0.53022945",
"0.5299302",
"0.5290787",
"0.5283423",
"0.52781403",
"0.5275811",
"0.5252679",
"0.5245034",
"0.52425444",
"0.52423286",
"0.5237689",
"0.5237689",
"0.52362114",
"0.52293307",
"0.52293307",
"0.52253336",
"0.5222759",
"0.52151215",
"0.5208622",
"0.51986855",
"0.51894844",
"0.51864225",
"0.51849973",
"0.51675576",
"0.5164765",
"0.51632726",
"0.51625997",
"0.51578367",
"0.51533145",
"0.51511985",
"0.51431155",
"0.5140138",
"0.513931",
"0.51350504",
"0.51311857",
"0.51311857",
"0.51311857",
"0.51311857",
"0.5129493",
"0.5128532",
"0.51152533",
"0.5112452",
"0.50837165",
"0.5080172",
"0.50789964",
"0.5064083",
"0.5057423",
"0.50517523",
"0.5044595",
"0.5043331",
"0.504229",
"0.5041482",
"0.5035103",
"0.5030293",
"0.50289565",
"0.5014307",
"0.5014119",
"0.5012463",
"0.5009447",
"0.50082254",
"0.50060177",
"0.50044394",
"0.50007945",
"0.49996957",
"0.49926314",
"0.49857202",
"0.4980394",
"0.4977534",
"0.4972932"
] |
0.54348123
|
20
|
Returns the API () described in the file Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.api => "1513120205"
|
def api
self.well_info.api
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def api(path)\n OodAppkit.files.api(path: path).to_s\n end",
"def api\n @api\n end",
"def api_base_path\n \"/lol/platform/#{api_version}\"\n end",
"def api_name\n to_s.split('::').last.gsub(/[^\\A]([A-Z])/, '_\\\\1').downcase\n end",
"def get_api_version\n :v201502\n end",
"def api\n return Runtime.instance.set_if(self, :api) do\n LapisLazuli::API.new\n end\n end",
"def get_api_version()\n return :v201502\n end",
"def api\n return @api\n end",
"def api_version\n self.class.get('/api')['api_ver']\n end",
"def parse_api api_yaml\n api = ::Google::Protobuf::Api.new\n api.name = api_yaml[NAME_KEY] if api_yaml.key? NAME_KEY\n api.version = api_yaml[VERSION_KEY] if api_yaml.key? VERSION_KEY\n api\n end",
"def load_api_config api_version\n lib = File.dirname(File.dirname(__FILE__))\n path = \"#{lib}/api_config/#{service_name}-#{api_version}.yml\"\n YAML.load(File.read(path))\n end",
"def docs api\n\t\tget_html \"#{@options[:docs]}/#{@apis[api][:url]}.htm\"\n\tend",
"def shellforce_api\n ShellForce.config.path + '/api'\nend",
"def config_apis\n source = \"#{Dir.pwd}/app/apis/#{@project_name}/#{@scaffold_name}s/base_apis.rb\"\n content = ['AppName','ScaffoldName', 'Model', 'model']\n replacement = [\"#{@project_class}\", \"#{model_class}s\", \"#{model_class}\", \"#{@scaffold_name}\"]\n for i in 0..3 do\n modify_content(source, content[i], replacement[i])\n end\n end",
"def api\n api = Chassis.signatures.to_a.sort { |a, b| a.first.to_s <=> b.first.to_s }\n api\n end",
"def api_path(path)\n \"/services/data/v#{@options[:api_version]}/#{path}\"\n end",
"def api_version\n @api_version ||= begin\n pool = self.pool.get_all[0]\n host = self.pool.get_master(pool)\n major = self.host.get_API_version_major(host)\n minor = self.host.get_API_version_minor(host)\n \"#{major}.#{minor}\"\n end\n end",
"def api_object\n unless $api\n $api = FyberAPI.new(\n 'b07a12df7d52e6c118e5d47d3f9e60135b109a1f',\n {\n appid: 157,\n format: 'json',\n device_id: '2b6f0cc904d137be2e1730235f5664094b83',\n locale: 'de',\n ip: '109.235.143.113'\n }\n )\n end\n $api\n end",
"def to_get_request\n 'get_%ss' % api_name\n end",
"def get_api_method\n return if params[:action] == 'index' && params[:controller] == 'api/docs'\n begin\n # load the parent module (e.g. EOL::Api::Search) to get the default version\n method_class = \"EOL::Api::#{params[:action].camelize}\".constantize\n rescue => e\n render_error(\"Invalid method: #{params[:action]}\")\n return nil\n end\n\n begin\n # load the proper version of the API method (e.g. EOL::Api::Search::V1_0)\n params[:version] ||= method_class::DEFAULT_VERSION\n @api_method = \"#{method_class}::V#{params[:version].tr('.', '_')}\".constantize\n rescue => e\n render_error(\"Invalid version: #{params[:version]}\")\n return nil\n end\n return @api_method\n end",
"def yaml_api\n \"github.com/api/v2/yaml\"\nend",
"def access_api(url)\n http = Net::HTTP.new(url.host, url.port)\n http.use_ssl = true\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n\n file = File.open('bin/key.rb')\n request = Net::HTTP::Get.new(url)\n request[\"x-rapidapi-host\"] = 'skyscanner-skyscanner-flight-search-v1.p.rapidapi.com'\n request[\"x-rapidapi-key\"] = file.read\n\n response = http.request(request).read_body\n response_hash = JSON.parse(response) \nend",
"def service_require\n ruby_file_path @api, service_name_full\n end",
"def get_api_version()\n return API_VERSION\n end",
"def api_version\n request('getAPIVersion')\n end",
"def api\n @api ||= Battlenet.new(:eu)\n end",
"def api\n @http ||= Http.new(config)\n end",
"def apis; end",
"def url_api\n Guidebox\n end",
"def name\n \"Stdapi: System\"\n end",
"def api_version; config[:api_version]; end",
"def api_framework\n source_node[:apiFramework]\n end",
"def api_framework\n source_node[:apiFramework]\n end",
"def api_framework\n source_node[:apiFramework]\n end",
"def get_api_version\n _make_request(:types)['version'].to_s\n end",
"def [](api_name)\n request.api = api_name\n self\n end",
"def api_version\n self.class.superclass.name.to_s.split('::').second.sub('V', '').to_i\n end",
"def last_api_version\n @last_api_version\nend",
"def api; end",
"def api; end",
"def api=(value)\n @api = value\n end",
"def api\n @config = ZipMoney::Configuration\n configure_api if @_api.nil?\n \t @_api\n end",
"def user_api\n $SDK_API\nend",
"def api_metadata\n service_id = @context.config.api.metadata['serviceId']\n return unless service_id\n\n service_id = service_id.gsub(' ', '_').downcase\n gem_version = @context[:gem_version]\n \"api/#{service_id}##{gem_version}\"\n end",
"def get_version\n prepare\n @api.get_api_version\n end",
"def api_model\n api_model_nane.constantize\n end",
"def api_config()\n AdwordsApi::ApiConfig\n end",
"def lws_api_get(path)\n # See also catalog_controller for use of ENV['LWS_...']\n url ||= ENV['LWS_API_URL']\n url ||= \"#{ENV['LWS_CORE_URL']}/api\" if ENV['LWS_CORE_URL']\n \n # http://localhost:8888/api/collections\n resp = Net::HTTP.get_response(URI.parse(\"#{url || 'http://127.0.0.1:8888/api'}#{path}\"))\n result = JSON.parse(resp.body)\n end",
"def api_mode; end",
"def coreApiEP\n\t\tCORE_API_URL_83\n\tend",
"def initialize(api)\n @api = api\n end",
"def api_path(path)\n \"/rest/v#{options[:api_version]}/#{path}\"\n end",
"def API_version(options={})\n return \"#{@major}.#{@minor}\"\n end",
"def api_version\n @api_version || \"2011-02-01\"\n end",
"def make_api_call (api_path)\n uri = URI.parse(GPS_CLIENT_SETTINGS[\"url\"] + api_path)\n http = Net::HTTP.new(uri.host, uri.port)\n if uri.scheme==\"https\"\n http.use_ssl = true\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n end\n request = Net::HTTP::Get.new(uri.request_uri)\n request['API-SECRET'] = client_secret\n response = http.request(request) \n make_adapter_response(response)\n end",
"def api_url\n return nil unless @auth\n\n if @auth.empty?\n warn \"There are no API configurations in #{@auth_file}\"\n return nil\n end\n\n if @auth.keys.size > 1\n warn \"There are #{@auth.keys.size} API configurations in #{@auth_file}\"\n return nil\n end\n\n @auth.keys.first\n end",
"def api_version\n self.class.api_version\n end",
"def url(path)\n \"#{API}/#{path}\"\n end",
"def api_class(options={})\n @api_class ||= {}\n return @api_class[options[:api] || self.api] if @api_class[options[:api] || self.api]\n\n @api_class[options[:api] || self.api] = ExternalAPI.const_get((options[:api] || self.api).to_s.gsub(/(?:^|_)(.)/) { $1.upcase })\n end",
"def get_definition(cls, bld, fun)\r\n bld.add(\"///\")\r\n bld.add(\"/// Web API get single \" + cls.getUName())\r\n bld.add(\"///\")\r\n\r\n get_body(cls, bld, fun)\r\n\r\n bld.endFunction\r\n end",
"def get_api_key()\n api_key = nil\n File.open(\"api_key.txt\").each do |line|\n api_key = line\n return api_key\n end\nend",
"def load_cached_api\n api = nil\n\n if File.exists?(self.class::API_CACHE)\n File.open(self.class::API_CACHE) do |file|\n api = Marshal.load(file)\n end\n else\n api = @client.discovered_api(self.class::API_NAME, self.class::API_VERSION)\n File.open(self.class::API_CACHE, 'w') do |file|\n Marshal.dump(api, file)\n end\n end\n\n api\n end",
"def file\n\t\tbrand(Rex::Post::Meterpreter::Extensions::Stdapi::Fs::File)\n\tend",
"def initialize(api_key, source, config = {})\n raise ArgumentError.new('Your need to specify your api key') unless api_key\n raise ArgumentError.new('You need to specify a source website') unless source\n\n\n defaults = {\n :api_version => API_VERSION\n }\n\n @config = defaults.merge(config).freeze\n @api_key = api_key\n @source = source\n @litmosURL = \"https://api.litmos.com/v#{@config[:api_version]}.svc/\"\n @devURL = \"http://apidev.litmos.com/v#{@config[:api_version]}.svc/\"\n end",
"def api_id\n chip_api.tmp_api_id\n end",
"def api_path\n @api_path ||= find_api_path(base_uri)\n end",
"def show\n\n active_doc = site_account.api_docs_services.published.find_by_id_or_system_name! params[:id]\n\n json = if active_doc.specification.swagger_2_0?\n active_doc.specification.as_json\n else\n ThreeScale::Swagger::Translator.translate! active_doc.body\n end\n\n respond_with json\n end",
"def get_existing_rest_api(api_name)\r\n apis = @client.get_rest_apis(limit: 500).data\r\n api = apis.items.select { |a| a.name == api_name }.first\r\n\r\n return api.id if api\r\n # nil is returned otherwise\r\n end",
"def api_version\n @api_version || :latest\n end",
"def get_api_version\n response = send_api_request(:index)\n if response[:returncode]\n response[:version].to_s\n else\n \"\"\n end\n end",
"def api(path,lastmodified = nil) #Returns the FRC API file for the specified path in JSON format.\n #Warning: api() returns an HTTP response while reqapi() returns a JSON string.\n begin\n \tputs \"I am accessing the API at path #{path}\"\n \toptions = { 'User-Agent' => \"https://github.com/2468scout/2468Scout-Ruby-Server\", #Dunno what this is but Isaac did it\n 'Authorization' => \"Basic #{$token}\", #Standard procedure outlined by their API\n 'accept' => \"application/json\" #We want JSON files, so we will ask for JSON\n \t}\n \t#FMS-OnlyModifiedSince will return just a 304\n \t#If-Modified-Since will return a 200 no matter what, for some reason\n \toptions['FMS-OnlyModifiedSince'] = lastmodified if lastmodified\n #puts options['If-Modified-Since']\n #open(\"#{$server}#{path}\", options).read\n toreturn = {}\n\n if $toggle_manual_input\n \tputs \"I want to access #{path}, but manual input is turned on! Please type the filename to use in its place.\"\n \tfilename = \"\"\n \twhile(!File.exists? filename)\n \t\tputs \"Try file name: \"\n \t\tfilename = gets\n \t\tputs \"Searching for the file #{filename}...\"\n \tend\n \tjsondata = retrieveJSON(filename)\n \ttoreturn = OpenStruct.new(:body => jsondata, :meta => {}, :staus => ['200', 'OK']) \n else\n\t open(\"#{$server}#{path}\", options) do |response|\n\t \tbody = \"\"\n\t \tresponse.each_line do |line|\n\t \t\tbody << line.to_s\n\t \tend\n\t \t#response.base_uri.to_s\n\t \ttoreturn = OpenStruct.new(:body => body, :meta => response.meta, :status => response.status)\n\t \t#must create a persistent object out of the response, as response is not accessible outside this method\n\t end\n\tend\n toreturn\n rescue => e\n \tputs \"Something went wrong #{e.class}, message is #{e.message}\"\n toreturn = '{}'\n if (e.message.include? '304') \n \ttoreturn = OpenStruct.new(:body => '{}', :status => ['304','Not Modified'])\n\tend\n\ttoreturn #If error, return empty JSON-ish, or 304 if 304\n end\nend",
"def api_rb(call)\n <<-EOS\n#{call[:id]} = http_#{call[:method]}(\n \"#{call[:endpoint]}\",\n #{field_param(call[:params])}\n)\nEOS\n end",
"def get_api_version_string(api_version)\n \"?api-version=#{api_version}\"\n end",
"def require_apis_to_base\n File.open(\"#{Dir.pwd}/app/apis/#{@project_name}/base.rb\", \"r+\") do |f| \n pos = f.pos \n rest = f.read\n f.seek pos\n f.write(\"require_relative '#{@scaffold_name}s/base_apis'\\n\") \n f.write(rest)\n end\n end",
"def get_api_version\n response = send_api_request(:index)\n response[:returncode] ? response[:version].to_s : \"\"\n end",
"def info\n standardize\n # Alphebatize the API hash\n @api_sort = @api_hash.sort\n # Convert to array because SQLite\n @api_arr = @api_sort.flat_map do |_, v|\n v.is_a?(Hash) ? v.map { |_, w| escape(w) } : escape(v)\n end\n end",
"def api_url(path)\n path\n end",
"def api_key\n token = self.api_token || self.create_api_token(:action => 'api')\n token.value\n end",
"def create_adwords_api\n config_filename = File.join(Rails.root, 'config', 'adwords_api.yml')\n @api = AdwordsApi::Api.new(config_filename)\n end",
"def url\n api_url\n end",
"def api_url\n @@API_URL\n end",
"def to_s\n self.api_version\n end",
"def to_s; \"#<Veritable::API url='#{api_base_url}'>\"; end",
"def set_api\n @api = Api.find(params[:id])\n end",
"def set_api\n @api = Api.find(params[:id])\n end",
"def new(host:, port:, ssl: false, username:, password:, api_version:)\n api = nil\n\n # check that the API version is implemented\n api_version_file = File.join(File.dirname(__FILE__), \"v#{api_version}\", \"api.rb\")\n if File.exist?(api_version_file)\n require api_version_file.sub('.rb', '')\n\n api = Object.const_get(\"PaloAlto::V#{api_version}::Api\").new(host: host,\n port: port,\n ssl: ssl,\n username: username,\n password: password)\n else\n raise \"API version '#{api_version}' is not implemented\"\n end\n\n api\n end",
"def api\n @api ||= WeatherApiCalls.new\n end",
"def api\n @api ||= Prismic.api('https://middleman-sandbox.cdn.prismic.io/api') || PrismicService.init_api\n end",
"def api_params\n params[:api]\n end",
"def api \n api = { }\n \n param_regex = Regexp.new '\\(\\[\\^\\\\\\\\\\/\\?\\#\\]\\+\\)'\n Nagira.routes.keys.each do |method|\n api[method] ||= []\n Nagira.routes[method].each do |r|\n path = r[0].inspect[3..-3]\n r[1].each do |parm|\n path.sub!(param_regex,\":#{parm}\")\n end\n path.gsub!('\\\\','')\n api[method] << path unless path.empty? \n end\n end\n api\n end",
"def api_key\n @api_key ||= config_value.split('-')[1].chomp\n end",
"def api_version\n @version\n end",
"def lib\n @data['lib']\n end",
"def version\n response = get('/getVersion', {}, false)\n ApiVersion.new(response.body['version'], response.body['builddate'])\n end",
"def api_url\n ENV.fetch('GLIMR_API_URL',\n 'https://glimr-api.taxtribunals.dsd.io/Live_API/api/tdsapi')\n end",
"def api\n @api ||= PrismicService.init_api\n end",
"def set_api\n @api = Api.find(params[:id])\n end",
"def inspect\n return 'Ballchasing API'\n end",
"def api_url\n \"#{@@base_url}/#{format}/#{resource}?apikey=#{@@api_key}#{parameters}\"\n end",
"def get_current_user_api\n $SDK_API\nend"
] |
[
"0.6092216",
"0.60680616",
"0.6053059",
"0.604105",
"0.59798735",
"0.5959112",
"0.5939222",
"0.58953714",
"0.58548737",
"0.5849631",
"0.57478416",
"0.5705776",
"0.57041574",
"0.5689066",
"0.5661654",
"0.56575954",
"0.5617997",
"0.56079394",
"0.56039745",
"0.55859435",
"0.5556376",
"0.5550989",
"0.5544181",
"0.55114716",
"0.5506974",
"0.5500253",
"0.54905593",
"0.5472213",
"0.54714257",
"0.5422094",
"0.54169464",
"0.54138136",
"0.54138136",
"0.54138136",
"0.54126745",
"0.5410808",
"0.5382149",
"0.5381614",
"0.5380937",
"0.5380937",
"0.53715384",
"0.5360308",
"0.5354433",
"0.53527176",
"0.5351398",
"0.53439146",
"0.5343265",
"0.534247",
"0.5341906",
"0.5336061",
"0.5325572",
"0.5315906",
"0.5293558",
"0.5290786",
"0.52903116",
"0.5289211",
"0.5285936",
"0.5276386",
"0.5276355",
"0.52754354",
"0.5270606",
"0.5266942",
"0.52625275",
"0.52623045",
"0.5260486",
"0.52554685",
"0.52530926",
"0.52342606",
"0.5225866",
"0.52144384",
"0.5209791",
"0.5208019",
"0.5203591",
"0.5201265",
"0.5196661",
"0.5193721",
"0.51882297",
"0.51806605",
"0.51641536",
"0.5162996",
"0.5162644",
"0.5158895",
"0.51542753",
"0.51518357",
"0.51518357",
"0.5150745",
"0.5150495",
"0.5142625",
"0.51337755",
"0.5130359",
"0.5125774",
"0.5125522",
"0.51135486",
"0.51104087",
"0.51028675",
"0.51015514",
"0.5094904",
"0.5093619",
"0.50920594",
"0.50917476"
] |
0.6546905
|
0
|
Returns the UWI (UNIQUE WELL ID) described in the file Returns API if UWI not found (for locations outside Canada) Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.uwi => "100091604920W300"
|
def uwi
self.well_info.uwi || self.well_info.api
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def name_of_uvhw(well)\n plate, r, c = find_uvhw(well)\n return \"Well #{plate.id}(#{'ABCD'[r]}#{c+1})\"\n end",
"def wpi\n data[:wpi]\n end",
"def get_WOEID()\n \t return @outputs[\"WOEID\"]\n \tend",
"def get_WOEID()\n \t return @outputs[\"WOEID\"]\n \tend",
"def wikipedia_url\n \"http://en.wikipedia.org/wiki/ISO_639:#{iso_639}\"\n end",
"def wsu_id\n \"UsernameToken-#{count}\"\n end",
"def institution_name\n @institution_name ||= File.read(file_path, :mode => \"rb\", :external_encoding => \"UTF-8\").strip\n rescue\n nil\n end",
"def uwt_id\n GraphQL::Schema::UniqueWithinType.encode(self.class.name, id)\n end",
"def uni(find)\n\tfor i in 0...0xFFFFF\n\t\th = (((i - 0x10000) / 0x400) + 0xD800).to_i.to_s(16)[-2..-1].to_i(16).chr\n\t\tl = ((i - 0x10000) % 0x400 + 0xDC00).to_i.to_s(16)[-2..-1].to_i(16).chr\n\n\t\tif(h == find[0] && l == find[1])\n\t\t\treturn URI.encode [i.to_i].pack('U')\n\t\tend\n\tend\nend",
"def store_uvhw(well)\n # choose the first non-full UVHP or a new UVHP if none available\n plate = find_all_uvhp.select{|plate| get_ncw(plate) != -1}.first || new_uvhp\n # find the next clean well of the plate\n ncw = get_ncw(plate)\n # calculate the corresponding position in the 2D array\n cols = plate.dimensions[1]\n r, c = ncw / cols, ncw % cols\n plate.set(r, c, well.id)\n # increment the plate's next clean well (-1 if no more clean wells)\n ncw = ncw < plate.matrix.flatten.size - 1 ? ncw + 1 : -1\n set_ncw(plate, ncw)\n # assign the well a new location\n well.location = name_of_uvhw(well)\n return plate\n end",
"def find_uvhw(well)\n # find the plate containing the well\n plate = find_all_uvhp.find{|plate| plate.matrix.flatten.include?(well.id)}\n return nil if plate == nil\n # find the row and column belonging to the well\n r, c = plate.find(well.id).first # NOTE: Collection class overrides find\n return plate, r, c\n end",
"def lookup(woeid, unit = Units::CELSIUS)\n acceptable_units = [Units::CELSIUS, Units::FARENHEIT]\n unit = Units::CELSIUS unless acceptable_units.include?(unit)\n\n url = ROOT + \"?q=select%20*%20from%20weather.forecast%20\"\n url += \"where%20woeid%3D#{woeid}%20and%20u%3D'#{unit}'&format=json\"\n\n doc = get_response url\n Response.new woeid, url, doc\n end",
"def load_wurfl(wurflfilepath)\n fallbacks = {}\n doc = XML::Document.file(wurflfilepath)\n doc.find(\"///devices/device\").each do |element| \n wurfl_id = element.attributes[\"id\"] \n h = @handsets[wurfl_id] ||= Wurfl::Handset.new(wurfl_id, element.attributes[\"user_agent\"], nil, element.attributes[\"actual_device_root\"])\n fall_back_id = element.attributes[\"fall_back\"]\n fallbacks[wurfl_id] = fall_back_id unless fall_back_id == \"root\"\n \n element.find(\"group/capability\").each do |capability|\n h[capability.attributes[\"name\"]] = capability.attributes[\"value\"]\n end\n end\n\n fallbacks.each {|k,v| @handsets[k].fallback = @handsets[v]}\n \n @handsets\n end",
"def insult_swabbie\n return case self.swab\n when :counter\n self.boatswain\n when :timestamp\n self.coxswain\n else\n \"\"\n end\n end",
"def wfid\n\n h.fei['wfid']\n end",
"def wfid\n\n h.fei['wfid']\n end",
"def discover_uaa\n info = server\n links = info['links'] || info[:links]\n uaa = links && (links['uaa'] || links[:uaa])\n\n uaa || target\n end",
"def lookup_by_woeid(woeid)\n raw = get request_url(woeid)\n Response.new(raw, options[:lang])\n end",
"def unit_of_work_id\n tags[UNIT_OF_WORK_ID] if tags\n end",
"def uid\n path = uid_file\n return nil if !path\n return nil if !path.file?\n return uid_file.read.chomp\n end",
"def sku\n (sku_type || 'xx').upcase + \n sku_id.to_s.rjust(3, '0') +\n sku_variant_id.to_s.rjust(2, '0') +\n (language_code || 'XX').upcase + '-' +\n (country_code || 'WW').upcase \n end",
"def set_huwaei\n @huwaei = Huwaei.find(params[:id])\n end",
"def load_field\n 'wc'\n end",
"def to_wcif\n {\n \"id\" => wcif_id,\n \"name\" => name,\n \"latitudeMicrodegrees\" => latitude_microdegrees,\n \"longitudeMicrodegrees\" => longitude_microdegrees,\n \"countryIso2\" => country_iso2,\n \"timezone\" => timezone,\n \"rooms\" => venue_rooms.map(&:to_wcif),\n \"extensions\" => [],\n }\n end",
"def get_location(user_location)\n\tclient=Weatherman::Client.new\n\tclient.lookup_by_location(user_location)\nend",
"def get_foreign_uic(birth_number)\n @@logger.debug \"Trying service for foreign student with bn #{birth_number}\"\n begin\n service_response = query_service(SERVICES[:foreign_uic] % birth_number)\n rescue Exception => e\n @@logger.error 'Something gone wrong with service ' + e\n next\n end\n begin\n uic = extract_uic(service_response)\n @@logger.debug \"Service and parsing successful.\"\n return uic\n rescue Exception => e\n @@logger.error \"Error parsing response: \" + e\n next\n end\n end",
"def api_id\n ENV['UNLEASHED_API_ID']\n end",
"def institution\n default = \"[INSTITUTION]\"\n result = local_study_affiliate\n result.blank? ? default : result\n end",
"def get_uic(birth_number)\n service = prepare_service(birth_number)\n @@logger.debug \"Trying service for student with bn #{birth_number}\"\n @@logger.debug service\n begin\n service_response = query_service(service)\n rescue Exception => e\n @@logger.error 'Something gone wrong with service ' + e\n end\n begin\n uic = extract_uic(service_response)\n @@logger.debug \"Service and parsing successful. Updating student\"\n return uic\n rescue Exception => e\n @@logger.error \"Error parsing response: \" + e\n end\n end",
"def institution\n Settings.HARVESTER.INSTITUTION.name\n end",
"def read_kuni (file,kuni)\n if can_see_this kuni\n erubis file \n end\n end",
"def api\n self.well_info.api\n end",
"def api_id\n chip_api.tmp_api_id\n end",
"def get_registry_unattend_path\n # HKLM\\System\\Setup!UnattendFile\n begin\n key = session.sys.registry.open_key(HKEY_LOCAL_MACHINE, 'SYSTEM')\n fname = key.query_value('Setup!UnattendFile').data\n return fname\n rescue Rex::Post::Meterpreter::RequestError\n return ''\n end\n end",
"def unit_path\n \"u_\" + image_path\n end",
"def URSI2GUIDandWBIC(thisURSI)\r\n\t$logger.debug { \"URSI2GUIDandWBIC: looking for GUID and WBIC for URSI: \" \r\n\t\t+ thisURSI }\r\n\r\n\ttags = $piggybank.get_tags_by_ursi thisURSI\r\n\tif tags.nil? or tags.size < 1\r\n\t\t$logger.warn { \" Couldn't find URSI '\" + thisURSI +\r\n\t\t\t\"' tags data in COINS!\" }\r\n\t \treturn [nil, nil]\r\n\tend\r\n\r\n\treturn [tags[\"RDoC GUID\"], tags[\"WBIC\"]]\r\nend",
"def set_usine\n @usine = Usine.find(params[:id])\n end",
"def map_ldu(ldu_code)\n LocalDeliveryUnit.find_by(code: ldu_code)\n end",
"def pickup_location_name(code)\n if Settings.ils.client == 'FolioClient'\n Folio::ServicePoint.name_by_code(code) || code\n else\n Mylibrary::Application.config.library_map[code] || code\n end\n end",
"def sku\n reference\n end",
"def get_outype(outype_id)\n path = \"/d2l/api/lp/#{$lp_ver}/outypes/#{outype_id}\"\n _get(path)\nend",
"def URSI2GUID(thisURSI)\r\n\t$logger.debug { \"URSI2GUID: looking for GUID for URSI: \" + thisURSI }\r\n\r\n\ttags = $piggybank.get_tags_by_ursi thisURSI\r\n\tif tags.nil? or tags.size < 1\r\n\t\t$logger.warn { \" Couldn't find URSI '\" + thisURSI +\r\n\t\t\t\"' tags data in COINS!\" }\r\n\t \treturn nil\r\n\tend\r\n\t$logger.debug { \" Tags: '\" + tags.to_s + \"'.\" }\r\n\r\n\treturn tags[\"RDoC GUID\"]\r\nend",
"def set_uen\n @uen = Uen.find(params[:id])\n end",
"def display_resource(rainwork)\n \"RW \\\"#{rainwork.name}\\\"\"\n end",
"def htlal_wiki_url\n \"http://learnanylanguage.wikia.com/wiki/#{name.gsub(' ', '_')}\"\n end",
"def get_institution(affi_string)\n found_inst = nil\n $affi_institutions.each do |institution|\n if affi_string.include?(institution) then\n if found_inst == nil then\n found_inst = institution\n elsif found_inst.length < institution.length then\n found_inst = institution\n end\n end\n end\n return found_inst\nend",
"def unoconv_pname\n 'LibreOffi'\n end",
"def get_oid\n \"wee_#{@canvas.current_component.object_id}\"\n end",
"def get_stat_file(epw_file)\n # Add SiteWaterMainsTemperature -- via parsing of STAT file.\n stat_file = \"#{File.join(File.dirname(epw_file.path.to_s), File.basename(epw_file.path.to_s, '.*'))}.stat\"\n unless File.exist? stat_file\n OpenStudio.logFree(OpenStudio::Info, 'BuildingSync.Building.get_stat_file', 'Could not find STAT file by filename, looking in the directory')\n stat_files = Dir[\"#{File.dirname(epw_file.path.to_s)}/*.stat\"]\n if stat_files.size > 1\n OpenStudio.logFree(OpenStudio::Error, 'BuildingSync.Building.get_stat_file', 'More than one stat file in the EPW directory')\n return nil\n end\n if stat_files.empty?\n OpenStudio.logFree(OpenStudio::Error, 'BuildingSync.Building.get_stat_file', 'Cound not find the stat file in the EPW directory')\n return nil\n end\n\n OpenStudio.logFree(OpenStudio::Info, 'BuildingSync.Building.get_stat_file', \"Using STAT file: #{stat_files.first}\")\n stat_file = stat_files.first\n end\n unless stat_file\n OpenStudio.logFree(OpenStudio::Error, 'BuildingSync.Building.get_stat_file', 'Could not find stat file')\n return nil\n end\n return stat_file\n end",
"def ward_info\n Windy.app_token = \"SzhuGRMWyG4gCUf08KDa693CK\"\n Windy.views.find_by_id('htai-wnw4').rows\n\tend",
"def set_lui\n @lui = Lui.find(params[:id])\n end",
"def get_institution_synonym(affi_string)\n found_inst = nil\n $institution_synonyms.keys.each do |inst_key|\n if affi_string.include?(inst_key.to_s) then\n if found_inst == nil then\n found_inst = inst_key.to_s\n elsif found_inst.length < inst_key.to_s.length then\n found_inst = inst_key.to_s\n end\n end\n end\n return found_inst\nend",
"def ssu_ids\n dwelling_units.map(&:ssu_id).compact.uniq\n end",
"def nonstandard_lro_file_name\n nonstandard_lro_file_path.split(\"/\").last\n end",
"def uds_path\n if mixed_http_and_uds?\n nil\n elsif parsed_url && unix_scheme?(parsed_url)\n path = parsed_url.to_s\n # Some versions of the built-in uri gem leave the original url untouched, and others remove the //, so this\n # supports both\n if path.start_with?('unix://')\n path.sub('unix://', '')\n else\n path.sub('unix:', '')\n end\n else\n uds_fallback\n end\n end",
"def get_nbe_id_from_obe_domain(obe_uri)\n uri = URI(obe_uri)\n new_ux_id\n\n response = http_get_response(uri)\n parsed = response.parsed_response\n\n @log.debug(\"New UX Id: #{parsed[\"nbeId\"]}\")\n\n if parsed[\"nbeId\"].nil? || parsed[\"nbeId\"].empty?\n else\n new_ux_id = get_page_id_for_given_nbe_id(uri, parsed[\"nbeId\"])\n end\n\n new_ux_id\n end",
"def wikipedia\n uri = nil\n @artist_data[\"relations\"].each do |rel|\n if rel[\"type\"] == \"wikipedia\"\n uri = rel[\"url\"][\"resource\"]\n end\n end\n return uri\n end",
"def well_name\n self.well_info.well_name\n end",
"def calcIUPACname\n getIncompleteName + Constants::ALKANE_SFIX\n end",
"def set_user_wine\n @user_wine = UserWine.find(params[:id])\n end",
"def hw_id\n # Observe that we sort the pathnames before turning them into MAC\n # addresses, because that gives us a stable ordering when run multiple\n # times on the same machine.\n hw_id = Pathname.glob('/sys/class/net/*').select do |sysfs|\n # This should skip everything except Ethernet style interfaces, which is\n # maybe the right thing to do? Different rule to what we use in DHCP\n # though, so maybe we should just skip if name == 'lo'?\n File.read(sysfs + 'type').chomp == '1'\n end.sort.map do |sysfs|\n address = File.read(sysfs + 'address').chomp\n # this ensures that we strip out empty address fields next\n address.empty? ? nil : address\n end.compact.join('_').gsub(':', '').downcase\n\n # Make sure we actually got *some* hardware ID.\n if hw_id.nil? or hw_id.empty?\n raise \"no network interfaces detected; cannot generate a hardware ID\"\n end\n\n hw_id\n end",
"def set_wine_type\n @wine_type = WineType.find(params[:id])\n end",
"def uf2_client\n @uf2_client ||= Microformats2.parse(@client_uid).first\n end",
"def uid_file\n return nil if !@data_dir\n @data_dir.join(\"creator_uid\")\n end",
"def osw_path\n @osw_abs_path\n end",
"def osw_path\n @osw_abs_path\n end",
"def illust_id\n return nil if novel_id.present?\n\n parsed_urls.each do |url|\n # http://www.pixiv.net/member_illust.php?mode=medium&illust_id=18557054\n # http://www.pixiv.net/member_illust.php?mode=big&illust_id=18557054\n # http://www.pixiv.net/member_illust.php?mode=manga&illust_id=18557054\n # http://www.pixiv.net/member_illust.php?mode=manga_big&illust_id=18557054&page=1\n if url.host == \"www.pixiv.net\" && url.path == \"/member_illust.php\" && url.query_values[\"illust_id\"].present?\n return url.query_values[\"illust_id\"].to_i\n\n # http://www.pixiv.net/en/artworks/46324488\n elsif url.host == \"www.pixiv.net\" && url.path =~ %r{\\A/(?:en/)?artworks/(?<illust_id>\\d+)}i\n return $~[:illust_id].to_i\n\n # http://www.pixiv.net/i/18557054\n elsif url.host == \"www.pixiv.net\" && url.path =~ %r{\\A/i/(?<illust_id>\\d+)\\z}i\n return $~[:illust_id].to_i\n\n # http://img18.pixiv.net/img/evazion/14901720.png\n # http://i2.pixiv.net/img18/img/evazion/14901720.png\n # http://i2.pixiv.net/img18/img/evazion/14901720_m.png\n # http://i2.pixiv.net/img18/img/evazion/14901720_s.png\n # http://i1.pixiv.net/img07/img/pasirism/18557054_p1.png\n # http://i1.pixiv.net/img07/img/pasirism/18557054_big_p1.png\n elsif url.host =~ /\\A(?:i\\d+|img\\d+)\\.pixiv\\.net\\z/i &&\n url.path =~ %r{\\A(?:/img\\d+)?/img/#{MONIKER}/(?<illust_id>\\d+)(?:_\\w+)?\\.(?:jpg|jpeg|png|gif|zip)}i\n return $~[:illust_id].to_i\n\n # http://i1.pixiv.net/img-inf/img/2011/05/01/23/28/04/18557054_64x64.jpg\n # http://i1.pixiv.net/img-inf/img/2011/05/01/23/28/04/18557054_s.png\n # http://i1.pixiv.net/c/600x600/img-master/img/2014/10/02/13/51/23/46304396_p0_master1200.jpg\n # http://i1.pixiv.net/img-original/img/2014/10/02/13/51/23/46304396_p0.png\n # http://i1.pixiv.net/img-zip-ugoira/img/2014/10/03/17/29/16/46323924_ugoira1920x1080.zip\n # https://i.pximg.net/img-original/img/2014/10/03/18/10/20/46324488_p0.png\n # https://i.pximg.net/img-master/img/2014/10/03/18/10/20/46324488_p0_master1200.jpg\n # https://i-f.pximg.net/img-original/img/2020/02/19/00/40/18/79584713_p0.png\n # https://tc-pximg01.techorus-cdn.com/img-original/img/2017/09/18/03/18/24/65015428_p4.png\n #\n # but not:\n #\n # https://i.pximg.net/novel-cover-original/img/2019/01/14/01/15/05/10617324_d84daae89092d96bbe66efafec136e42.jpg\n # https://img-sketch.pixiv.net/uploads/medium/file/4463372/8906921629213362989.jpg\n elsif url.host =~ /\\A(?:[^.]+\\.pximg\\.net|i\\d+\\.pixiv\\.net|tc-pximg01\\.techorus-cdn\\.com)\\z/i &&\n url.path =~ %r{\\A(/c/\\w+)?/img-[a-z-]+/img/#{DATE}/(?<illust_id>\\d+)(?:_\\w+)?\\.(?:jpg|jpeg|png|gif|zip)}i\n return $~[:illust_id].to_i\n end\n end\n\n nil\n end",
"def wfid\n\n l = [ @expressions, @errors, @stored_workitems ].find { |l| l.any? }\n\n l ? l.first.fei.wfid : nil\n end",
"def lookup_by_location(location)\n lookup = WoeidLookup.new\n woeid = lookup.get_woeid(location)\n lookup_by_woeid(woeid)\n end",
"def iso_week_num(wkst)\n iso_year_and_week_num(wkst)[1]\n end",
"def firmware_name\n \"Little Wire\"\n end",
"def url(item)\n 'http://mit.worldcat.org/oclc/' + \\\n item.xpath('oclcterms:recordIdentifier[not(@xsi:type)]').text.strip\n end",
"def set_utensilname\n @utensilname = Utensilname.find(params[:id])\n end",
"def file_link\n return \"#{SITE_URL}system/ufiles/#{id}/original/#{ufile_file_name}\"\n end",
"def iso_file\n resource[:iso_file].first[\"name\"] if resource[:iso_file]\n end",
"def country_us()\n @request_data = {\n\t\t\t\"type\"\t\t=> \"home\",\n \"ip\" => \"12.25.205.51\",\n \"session\" => \"new\",\n \"cuid\" => \"new\",\n \"lang\" => \"en\",\n \"site\" => \"ctshirts\",\n \"currentURI\" => \"http://www.ctshirts.co.uk\",\n \"previousURI\" => \"http://www.ctshirts.co.uk\",\n \"clientToken\" => \"677ab692r2t3u4t\", \n \"recContent\" => \"refCodeOnly\",\n }\n @json_request = \"\"\n @response_times = []\n end",
"def set_urun\n @urun = Urun.find(params[:id])\n end",
"def wave_makers\n LookUp::profiles_for_wavemakers_on_home\n end",
"def tow\n auto_shop.tow_vehicle\n end",
"def tow\n auto_shop.tow_vehicle\n end",
"def GetPlatformOfFile ( fl )\n platforms = { \"a1\" => \"AQUA-1\", \"t1\" => \"TERRA-1\", \"npp\" => \"NPP\"}\n \n x = File.basename(fl).split(\".\").first\n puts x\n return platforms[x] if ( platforms[x])\n return \"unknown\"\nend",
"def start_wapl\n return '<wapl xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"http://wapl.wapple.net/wapl.xsd\">'\n end",
"def set_wine_oenologist\n @wine_oenologist = WineOenologist.find(params[:id])\n end",
"def ou_to_short(name)\n name = name.upcase\n\n case name\n when \"DSS IT SERVICE CENTER\", \"DSS IT SHARED SERVICE CENTER\"\n return \"IT\"\n when \"DSS HR/PAYROLL SERVICE CENTER\"\n return \"HR\"\n when \"CALIFORNIA HISTORY SS PROJECT\"\n return \"CHP\"\n when \"UC CENTER SACRAMENTO\"\n return \"UCCS\"\n when \"HEMISPHERIC INSTITUTE-AMERICAS\"\n return \"PHE\"\n when \"HISTORY PROJECT\", \"HISTORY PROJECT UCD\"\n return \"HP\"\n when \"SOCIAL SCIENCES PROGRAM\"\n return \"SSP\"\n when \"PHYSICAL EDUCATION PROGRAM\"\n return \"PHE\"\n when \"DSS RESEARCH SERVICE CENTER\"\n return \"RSC\"\n when \"GEOGRAPHY\"\n return \"GEO\"\n when \"ANTHROPOLOGY\"\n return \"ANT\"\n when \"COMMUNICATION\"\n return \"CMN\"\n when \"ECONOMICS\"\n return \"ECN\"\n when \"HISTORY\"\n return \"HIS\"\n when \"LINGUISTICS\"\n return \"LIN\"\n when \"MILITARY SCIENCE\"\n return \"MSC\"\n when \"PHILOSOPHY\"\n return \"PHI\"\n when \"POLITICAL SCIENCE\"\n return \"POL\"\n when \"PSYCHOLOGY\"\n return \"PSC\"\n when \"EASTERN ASIAN STUDIES\"\n return \"EAS\"\n when \"INTERNATIONAL RELATIONS\"\n return \"IRE\"\n when \"MIDDLE EAST/SOUTH ASIA STUDIES\", \"MIDDLE EAST/SOUTH ASIA PROGRAM\"\n return \"MSA\"\n when \"SCIENCE & TECHNOLOGY STUDIES\"\n return \"STS\"\n when \"CENTER FOR MIND AND BRAIN\", \"CENTER FOR MIND & BRAIN\"\n return \"CMB\"\n when \"SOCIOLOGY\"\n return \"SOC\"\n when \"COM, PHIL & LIN RED CLUSTER\"\n return \"RED\"\n when \"POLI SCI, IR ORANGE CLUSTER\", \"SOCIAL SCIENCE ORANGE CLUSTER\"\n return \"ORANGE\"\n when \"ECON, HIS, MS BLUE CLUSTER\", \"SOCIAL SCIENCES BLUE CLUSTER\"\n return \"BLUE\"\n when \"ANT, SOC GREEN CLUSTER\", \"SOCIAL SCIENCES GREEN CLUSTER\"\n return \"GREEN\"\n when \"L&S DEANS - SOCIAL SCIENCES\"\n return \"DEANS\"\n when \"PSYCH, CMB YELLOW CLUSTER\", \"SOCIAL SCIENCE YELLOW CLUSTER\"\n return \"YELLOW\"\n when \"EDUCATION - PH.D.\"\n return \"EDU\"\n when \"COMMUNITY DEVELOPMENT\"\n return \"ComDev\"\n when \"NEUROSCIENCE\", \"CENTER FOR NEUROSCIENCE\"\n return \"NueroSci\"\n when \"CENTER FOR INNOVATION STUDIES\"\n return \"CSIS\"\n when \"ASUCD\", \"UC DAVIS\", \"ASIAN AMERICAN\", \"UNIVERSITY EXTENSION\", \"CHEDDAR\", \"STUDENT EMPLOYMENT CENTER\",\n \"TEMPORARY EMPLOYMENT SERVICE\", \"CAMPUS RECREATION AND UNIONS\", \"CRESS DEPARTMENT\", \"LIBRARY\", \"POLICE\",\n \"COMPARATIVE LITERATURE\", \"PRIMATE CENTER\", \"L&S DEANS - U/G ED & ADVISING\", \"STATISTICS\",\n \"AGR & ENV SCI DEANS OFFICE\", \"OFFICE OF THE CHANCELLOR\", \"UNDERGRADUATE ADMISSIONS\",\n \"UNIVERSITY WRITING PROGRAM\", \"TEXTILES & CLOTHING\", \"STUDENT HOUSING\", \"ENGLISH\", \"ANIMAL SCIENCE\",\n \"IRB ADMINISTRATION\", \"SCHOOL OF LAW-DEANS OFFICE\", \"STUDENT ACADEMIC SUCCESS CTR\", \"GERMAN & RUSSIAN\",\n \"INTERCOLLEGIATE ATHLETICS\", \"HUMAN ECOLOGY\", \"GRADUATE DIVISION\", \"MED: NEUROLOGY\",\n \"ENVIRONMENTAL TOXICOLOGY\", \"SCHOOL OF MED - STAFF\", \"L&S DEANS - DEVELOPMENT\",\n \"TEMPORARY EMPLOYMENT POOL ADMN\", \"SCHOOL OF MED - APS\", \"MED: GENERAL PEDIATRICS\",\n \"MED:PSYCHIATRY & BEHAV SCI\", \"NATIVE AMERICAN STUDIES\", \"ART\", \"VP UNDERGRADUATE EDUCATION\", \"GEOLOGY\",\n \"VM: CTR COMPARATIVE MEDICINE\", \"ENGR COMPUTER SCIENCE\", \"MED: DIV OF INTERNAL MED\",\n \"FM: CUSTODIAL SERVICES\", \"VOORHIES ADMINISTRATIVE UNIT\", \"MED: OPHTHALMOLOGY\", \"MED: PUBLIC HEALTH SCIENCES\",\n \"NEURO PHYSIO & BEHAVIOR\", \"INST OF TRANSPORTATION STUDIES\", \"ENVIRONMENTAL HEALTH & SAFETY\",\n \"MEDIEVAL STUDIES\", \"EDUCATION\", \"ACADEMIC AFFAIRS\", \"ANR SUSTAINABLE AG PROG\"\n return nil\n else\n Rails.logger.warn \"AD Sync: Missing OU for translation to container name: #{name}\"\n ActivityLog.err!(\"Could not translate unknown organization to AD group equivalent: #{name}\", ['active_directory'])\n end\n\n return false\nend",
"def pull_ssid(url)\n url =~ /\\?h3fileid\\=(\\d+)/\n return $1\n end",
"def to_id(fei)\n\n a = [ Ruote.to_storage_id(fei) ]\n\n a.unshift(@store_name) if @store_name\n\n a.unshift('wi')\n\n a.join('!')\n end",
"def location\n self.well_info.location\n end",
"def show\n @syllabus = Syllabus.find params[:id]\n end",
"def get_location(location)\n client = Weatherman::Client.new\n client.lookup_by_location(location)\nend",
"def getSomeCoolName\n\t\tnames = File.open(\"NazwyKonferencji\").read.split(\"\\n\")\n\t\tnames[rand(names.size)]\n\tend",
"def chorus_url\n /ju=(.*)&/.match(@openx_url)[1]\n end",
"def wldap32\n client.railgun.wldap32\n end",
"def getUnit(db, uid)\n\tunit = UnitAbstract.new(db, uid)\n\ttype = unit.type\n\t\n\tif type == 'human'\n\t\treturn UnitHuman.new(db, uid)\n\tend\n\t\n\tunit\nend",
"def eng_unit_user_tag; eng_unit_type.tag rescue \"\"; end",
"def organizational_unit\n self[:OU]\n end",
"def create_linguo_file\n create_file 'config/initializers/linguo.rb', \"Linguo.api_key = ENV['LINGUO_API_KEY']\"\n end",
"def set_yunwei\n @yunwei = Yunwei.find(params[:id])\n end",
"def find_wikidata_item_by_steam_app_id(app_id)\n endpoint = \"https://query.wikidata.org/sparql\"\n \n client = SPARQL::Client.new(\n \"https://query.wikidata.org/sparql\",\n method: :get,\n headers: { 'User-Agent': \"Connor's Random Ruby Scripts Data Fetcher/1.0 (connor.james.shea@gmail.com) Ruby 2.6\" }\n )\n sparql = query(app_id)\n begin\n rows = client.query(sparql)\n rescue SocketError => e\n puts e\n sleep 5\n return nil\n end\n\n # If there are 0 rows (no data returned) or more than one row, just skip it.\n if rows.size != 1\n print '.'\n return nil\n end\n return_row = {}\n rows.each do |row|\n return_row = { url: row.to_h[:item].to_s, title: row.to_h[:itemLabel].to_s }\n end\n\n return return_row\nend",
"def institution\n @institution ||= Institutions.institutions[institution_code.to_sym]\n end",
"def institution\n @institution ||= Institutions.institutions[institution_code.to_sym]\n end"
] |
[
"0.58519405",
"0.55437887",
"0.5113649",
"0.5113649",
"0.5034688",
"0.50089514",
"0.49868485",
"0.49679846",
"0.4937397",
"0.4928996",
"0.48776057",
"0.48640478",
"0.48640436",
"0.4858467",
"0.48494008",
"0.48494008",
"0.48388565",
"0.47967997",
"0.4796675",
"0.47878236",
"0.47831476",
"0.47545874",
"0.47346678",
"0.47313395",
"0.4721018",
"0.47182056",
"0.47099218",
"0.46829808",
"0.46752024",
"0.46606326",
"0.46570542",
"0.46524978",
"0.4651846",
"0.46485487",
"0.46444842",
"0.46413302",
"0.4617231",
"0.46166295",
"0.46162772",
"0.46092096",
"0.4608376",
"0.46071997",
"0.460312",
"0.45911607",
"0.45865157",
"0.45813024",
"0.45802292",
"0.45610496",
"0.45457363",
"0.453713",
"0.4536774",
"0.45335874",
"0.4532456",
"0.4520119",
"0.45149884",
"0.4502508",
"0.45017305",
"0.450033",
"0.44994074",
"0.44983852",
"0.44965783",
"0.44953534",
"0.44904444",
"0.44687447",
"0.44586024",
"0.44586024",
"0.44476154",
"0.4447523",
"0.44433144",
"0.44426474",
"0.44404817",
"0.44329032",
"0.44312462",
"0.4429249",
"0.4423337",
"0.44215694",
"0.4418584",
"0.44170293",
"0.4416417",
"0.4416417",
"0.4413599",
"0.44135684",
"0.44075117",
"0.44073105",
"0.4406158",
"0.4402425",
"0.43934503",
"0.43853375",
"0.4383849",
"0.43815646",
"0.43811977",
"0.43799245",
"0.43793654",
"0.43763968",
"0.43711755",
"0.43700212",
"0.4367486",
"0.43579435",
"0.4355751",
"0.4355751"
] |
0.7319451
|
0
|
Returns the state described in the file Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.state => "KANSAS"
|
def state
self.well_info.state
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def state_file\n return File.join(File.dirname(__FILE__), 'state.json')\n end",
"def load_state\n begin\n if File.file?(\"#{$statefile}\") && File.readable?(\"#{$statefile}\") \n @current_state = File.read(\"#{$statefile}\").strip.split(':')\n end\n rescue\n error('Invalid Resume Point')\n exit 1\n end\n end",
"def load file='GOL.sav'\n self.state=File.open(file,'r') do |f|\n Marshal.load(f)\n end\n end",
"def state_name\n state_name = CS.states(:us)[ self.try(:state).try(:to_sym) ]\n end",
"def state\n self[:ST]\n end",
"def load_state file=nil\n file=App.outpath + \"save.rb\" if file.nil?\n f=File.open(file,'r')\n content=f.read\n # puts content\n App.out= YAML.load(content)\n f.close\nend",
"def get_state(name)\n retrieved_state = nil\n @states.each do |state|\n if (state.name == name)\n retrieved_state = state\n break\n end\n end\n if (retrieved_state.nil?)\n raise Fae::StateNotFoundException, \"State #{name} was not found in this Finite Automata. Ensure that all states have outputs for #{@language.characters}\"\n end\n retrieved_state\n end",
"def state_filename\n File.join(@project.vartmp_dir, '.state.yaml')\n end",
"def get_state(name)\n name = name.to_sym\n (@states.detect { |st| st.name == name }).value\n end",
"def state\n status.state name\n end",
"def load_state\n return YAML.load(self.state)\n end",
"def fromStateString(line, s)\n\ti = s\n\tuntil line[i] == '\t' || i == line.length\n\t\ti = i+1\n\t\tif i>7\n\t\t\tputs 'ERROR: cannot read line in fromStateString'\n\t\t\treturn -1\n\t\tend\n\tend\n\treturn line[s..i-1]\nend",
"def aasm_read_state(_name = :default)\n state.try(:to_sym).presence || self.class.aasm.initial_state\n end",
"def read_state\n end",
"def state()\n info[:state]\n end",
"def state\n @@states[@state]\n end",
"def state\n info[:state]\n end",
"def get_state\n \"Treasury state: #{@resources}\"\n end",
"def state\n [\n [\"AC\", \"Acre\"],\n [\"AL\", \"Alagoas\"],\n [\"AP\", \"Amapa\"],\n [\"AM\", \"Amazonas\"],\n [\"BA\", \"Bahia\"],\n [\"CE\", \"Ceara\"],\n [\"DF\", \"Distrito Federal\"],\n [\"ES\", \"Espirito Santo\"],\n [\"GO\", \"Goias\"],\n [\"MA\", \"Maranhao\"],\n [\"MT\", \"Mato Grosso\"],\n [\"MS\", \"Mato Grosso do Sul\"],\n [\"MG\", \"Minas Gerais\"],\n [\"PA\", \"Para\"],\n [\"PB\", \"Paraiba\"],\n [\"PR\", \"Parana\"],\n [\"PE\", \"Pernambuco\"],\n [\"PI\", \"Piaui\"],\n [\"RJ\", \"Rio de Janeiro\"],\n [\"RN\", \"Rio Grande do Norte\"],\n [\"RS\", \"Rio Grande do Sul\"],\n [\"RO\", \"Rondonia\"],\n [\"RR\", \"Roraima\"],\n [\"SC\", \"Santa Catarina\"],\n [\"SP\", \"Sao Paulo\"],\n [\"SE\", \"Sergipe\"],\n [\"TO\", \"Tocantins\"],\n ]\n end",
"def state\n ret = request('getState')\n STATE_TO_STR[ ret['statecode'] ]\n end",
"def load_state\n save_file = File.read(\"saved_state.json\")\n json_hash = JSON.parse(save_file)\n @secret_word = json_hash[\"secret_word\"]\n @display_content = json_hash[\"display_content\"]\n @failed_attemps = json_hash[\"failed_attemps\"]\n end",
"def load_state\n if File.file?(STATE_FILE)\n state = RightScale::JsonUtilities::read_json(STATE_FILE)\n @log_level = state['log_level'] || Logger::INFO\n Log.info(\"Initializing CookState from #{STATE_FILE} with #{state.inspect}\") if @log_level == Logger::DEBUG\n\n @has_downloaded_cookbooks = state['has_downloaded_cookbooks']\n @startup_tags = state['startup_tags'] || []\n @reboot = state['reboot']\n @log_file = state['log_file'] # nil if not in state loaded from disk\n end\n true\n end",
"def get_state(division)\n challenge_states.find_by(division: division).state\n end",
"def name\n state_name\n end",
"def state_file_path(state)\n \"#{@data_dir}/#{PathConstants::STATES_DIR}/#{state.filename}.geojson\"\n end",
"def state\n params['state']\n end",
"def state\n data['State']\n end",
"def state\n [\n [\"AC\",\"Acre\"],\n [\"AL\",\"Alagoas\"],\n [\"AP\",\"Amapa\"],\n [\"AM\",\"Amazonas\"],\n [\"BA\",\"Bahia\"],\n [\"CE\",\"Ceara\"],\n [\"DF\",\"Distrito Federal\"],\n [\"ES\",\"Espirito Santo\"],\n [\"GO\",\"Goias\"],\n [\"MA\",\"Maranhao\"],\n [\"MT\",\"Mato Grosso\"],\n [\"MS\",\"Mato Grosso do Sul\"],\n [\"MG\",\"Minas Gerais\"],\n [\"PA\",\"Para\"],\n [\"PB\",\"Paraiba\"],\n [\"PR\",\"Parana\"],\n [\"PE\",\"Pernambuco\"],\n [\"PI\",\"Piaui\"],\n [\"RJ\",\"Rio de Janeiro\"],\n [\"RN\",\"Rio Grande do Norte\"],\n [\"RS\",\"Rio Grande do Sul\"],\n [\"RO\",\"Rondonia\"],\n [\"RR\",\"Roraima\"],\n [\"SC\",\"Santa Catarina\"],\n [\"SP\",\"Sao Paulo\"],\n [\"SE\",\"Sergipe\"],\n [\"TO\",\"Tocantins\"],\n ]\n end",
"def state\n states.first\n end",
"def load_state(row)\n \t\tstate_name = state row\n \t\tstate_obj = State.find_by_name(state_name)\n\t\tunless state_obj\n\t \t\tstate_obj = State.new({name: state_name})\n\t \t\tstate_obj.save\n\t \tend\n\t \treturn state_obj\n \tend",
"def links_state_fname(dest_path)\n return \"#{dest_path}/mythtv-link.state\", \"20101018\"\nend",
"def state\n country = ISO3166::Country[country_residence]\n if country.try(:subdivisions?)\n country.subdivisions[state_code].try(:[], \"name\")\n else\n state_code\n end\n end",
"def human_state_name\n I18n.t \"activerecord.state_machines.tramway/core/application_record.state.states.#{state}\"\n end",
"def load\n statefile_filename = state_filename\n if File.exist?(statefile_filename) &&\n File.file?(statefile_filename) &&\n File.readable?(statefile_filename)\n $log.debug \"Loading state from #{statefile_filename}\"\n @state = YAML.load_file(statefile_filename)\n else\n $log.debug 'No statefile found.'\n clean\n end\n @changed = false\n end",
"def lex_state_\n @lex_state\n end",
"def state\n object.human_state_name\n end",
"def state\n data[:state]\n end",
"def state\n @state.first\n end",
"def state_str\n ZONE_STATES[state]\n end",
"def save file='GOL.sav'\n File.open(file,'w') do |f|\n Marshal.dump(state,f)\n end\n end",
"def read_state\n logger.info \"Reading current state from #{configuration.state_file}\" do\n state_file = File.expand_path(configuration.state_file)\n if File.exist?(state_file)\n begin\n JSON.parse(IO.read(state_file))\n rescue => e\n raise e.class, \"Unable to read/parse state file\\n #{e}\"\n end.each { |uid,params| @run_context.add_state uid, params }\n else\n logger.info \"State file does not exist at #{state_file}. Creating...\"\n state_dir = File.dirname(state_file)\n if Dir.exist? state_dir\n File.write state_file, {}.to_json\n else\n raise \"Cannot create state file in #{state_dir}. Does that directory exist?\"\n end\n end\n\n logger.debug \"Found #{@run_context.state.count} resource(s) in state:\"\n @run_context.state.each { |uid,res| logger.debug \" #{uid}\" }\n end\n end",
"def parse_tf_state(path)\n check_terraform_applied\n\n tf_state = YAML.load(File.read(path))\n tf_output = tf_state[\"modules\"].first[\"outputs\"]\n tf_output.map { |k, v| tf_output[k] = v[\"value\"] }\n\n tf_output\n end",
"def state_string()\n ss = 'UNKNOWN'\n case @state\n when STARTING\n ss = 'STARTING'\n when STOPPED\n ss = 'STOPPED'\n when RUNNING\n ss = 'RUNNING'\n when CLOSING\n ss = 'CLOSING'\n when BLOCKED\n ss = 'BLOCKED'\n when STEP\n ss = 'STEP'\n end\n ss\n end",
"def load\n config = YAML.load_file @config_path\n @path = config['steam']\n end",
"def workflow_state(workflow_id:)\n get(url: \"#{@url}workflows/#{workflow_id}/state\")\n end",
"def state_path(path); end",
"def state\n module_name = self.class.name.underscore.gsub!('skej/state_logic/','')\n @STATE_KEY ||= module_name.to_sym\n end",
"def state_file_path\n File.join(RIGHT_LINK_SPEC_HELPER_TEMP_PATH, '__state.js')\n end",
"def read_vm_state vmname\n full_name = \"#{File.basename __dir__}_#{vmname}\"\n cmd = VMSTATE_CMD_TEMPLATE % [full_name]\n output = `#{cmd}`\n\n if output =~ /^name=\"<inaccessible>\"$/\n return :inaccessible\n elsif output =~ /^VMState=\"(.+?)\"$/\n return $1.to_sym\n end\n\n nil\nend",
"def final_state\n aasm.states.last.name\n end",
"def state(*args)\n result = self.info(\"--state\", *args).collect{ |str| str.scan(REGEX_STATE) }\n result.flatten!.compact!\n\n result.first.strip.downcase.to_sym\n end",
"def input\n lines = File.new('day12_input.txt').readlines()\n initial_state = lines[0].match('initial state:\\s*([^\\n]*)')[1]\n .chars\n .each_with_index\n .map { |x, i| [i, x] }\n rules = lines[2...lines.length].map { |item|\n item.strip.split(\" => \")\n }\n return initial_state, rules\nend",
"def get_state(key)\n @state[key]\n end",
"def state_at(state)\n @state_at[state_to_const(state)]\n end",
"def get_state(version)\n my_version = get_version(version)\n my_version['state']\n end",
"def state_name\n @state = State.find(state_id)\n @state[:name]\n end",
"def fact_s\n File.read('fact.vs')\nend",
"def sat\n state[\"sat\"]\n end",
"def state_str\n VN_STATES[state]\n end",
"def describe_state(state)\n $states[state.to_sym].last.join(' ,')\nend",
"def state\n data.state\n end",
"def state\n data.state\n end",
"def state; @doc['state']; end",
"def state; @doc['state']; end",
"def known_states; end",
"def known_states; end",
"def known_states; end",
"def current_state_s\n self.current_state.to_s.humanize.downcase\n end",
"def current_state_s\n self.current_state.to_s.humanize.downcase\n end",
"def initialize\n @state_file = \"./workspace.json\"\n get_state\n self\n end",
"def state\n self['STATE'].to_i\n end",
"def state\n self['STATE'].to_i\n end",
"def state\n self['STATE'].to_i\n end",
"def state\n self['STATE'].to_i\n end",
"def state\n self['STATE'].to_i\n end",
"def state\n self['STATE'].to_i\n end",
"def getKeyState(key)\n MSketchyPhysics3.getKeyState(key)\nend",
"def states\n\t[:shelf,:in_use,:borrowed,:misplaced,:lost]\nend",
"def getKeyState(key)\r\n MSketchyPhysics3.getKeyState(key)\r\nend",
"def read_state\n read_vm_option('status').strip.to_sym\n end",
"def for_state(state)\n labels_by_state[state]\n end",
"def state\n @game.state\n end",
"def state_code\n decode hash[\"StateCode\"]\n end",
"def fetch_sensor_state\n \"#{entry_on}#{inside_on}#{exit_on}#{@beam_broken}\".to_i(2)\n end",
"def l(filename)\n load \"#{filename}.rb\"\nend",
"def step3g_fluctuation_source(path)\n return \"#{path.pathmap('%d')}/nreads.RData\"\nend",
"def get_services_state()\n file = File.read('config/status.json')\n data_hash = JSON.parse(file)\n return data_hash\n end",
"def load_states(fname)\n init_kvstore unless @kv_initialized\n\n if @update_on_kvstore\n @kvstore.load_optimizer_states(fname)\n @optimizer = @kvstore.updater.optimizer\n else\n states = IO.binread(fname)\n @updaters.each do |updater|\n updater.set_states(states)\n updater.optimizer = @updaters[0].optimizer\n end\n @optimizer = @updaters[0].optimizer\n end\n end",
"def state\n object.state_code\n end",
"def state\n domain_info[:state]\n end",
"def state\n domain_info[:state]\n end",
"def read_tsbs(line)\n case line\n when TSBS::CollapSound\n @collapsound = RPG::SE.new($1.to_s,$2.to_i,$3.to_i)\n when TSBS::SBS_Start_S\n @load_tsbs = true\n @use_sprite = true\n @sprite_name = $1.to_s\n when TSBS::SBS_Start\n @load_tsbs = true\n when TSBS::SBS_End\n @load_tsbs = false\n end\n super(line)\n end",
"def state\n @state\n end",
"def current_state\n find_state(@current_state_name)\n # TODO: add caching, i.e. with `@current_state ||= ...`\n end",
"def state_str\n MARKETPLACEAPP_STATES[state]\n end",
"def translate_state_from(workflow)\n workflow.current_state\n end",
"def state_str\n VM_STATE[state]\n end",
"def state_str\n VM_STATE[state]\n end",
"def lcm_state_str\n LCM_STATE[lcm_state]\n end",
"def lcm_state_str\n LCM_STATE[lcm_state]\n end"
] |
[
"0.6223619",
"0.59959173",
"0.5980139",
"0.59111553",
"0.5908104",
"0.5802069",
"0.57481354",
"0.5739185",
"0.5670909",
"0.55981153",
"0.5576716",
"0.55691576",
"0.55563766",
"0.5542589",
"0.548392",
"0.5470379",
"0.5461593",
"0.5456341",
"0.54466414",
"0.54140544",
"0.54031235",
"0.5388105",
"0.53845847",
"0.53734714",
"0.53674257",
"0.53533536",
"0.5350758",
"0.53441095",
"0.53363955",
"0.53348285",
"0.53240097",
"0.53165114",
"0.53103185",
"0.5307154",
"0.5300904",
"0.5285697",
"0.5279325",
"0.52751124",
"0.5273019",
"0.5264106",
"0.52575886",
"0.5252865",
"0.5234357",
"0.5225925",
"0.5222764",
"0.521926",
"0.5213468",
"0.5212235",
"0.51791507",
"0.51661724",
"0.5158327",
"0.51468426",
"0.5145886",
"0.5136299",
"0.51320076",
"0.511412",
"0.5112461",
"0.5096681",
"0.5080192",
"0.50761205",
"0.50659627",
"0.50659627",
"0.5064594",
"0.5064594",
"0.5048565",
"0.5048565",
"0.5048565",
"0.5041367",
"0.5041367",
"0.5039829",
"0.50320345",
"0.50320345",
"0.50320345",
"0.50320345",
"0.50320345",
"0.50320345",
"0.50271744",
"0.50263464",
"0.5016934",
"0.50066775",
"0.5006344",
"0.5004495",
"0.5001842",
"0.5000537",
"0.49813706",
"0.4980079",
"0.49788997",
"0.49710786",
"0.49554533",
"0.49535254",
"0.49535254",
"0.49507585",
"0.49442965",
"0.4931435",
"0.49268773",
"0.4924085",
"0.49206436",
"0.49206436",
"0.4919277",
"0.4919277"
] |
0.59478986
|
3
|
Returns the county described in the file Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.county => "KENAI"
|
def county
self.well_info.county
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def business_county\n business_location.county if business_location.present?\n end",
"def decode_county\n\t#\tcase county_code.to_s.slice(-2,2)\n\t#\twhat if '01' or '1' or 1 or '12341234123401'\n\t\tcase sprintf('%02d',self.to_i).to_s.slice(-2,2).to_i\n\t#\t\twhen 0 then the given state code was all text\n\t\t\twhen 1 then 'Alameda'\n\t\t\twhen 2 then 'Alpine'\n\t\t\twhen 3 then 'Amador'\n\t\t\twhen 4 then 'Butte' \n\t\t\twhen 5 then 'Calaveras' \n\t\t\twhen 6 then 'Colusa' \n\t\t\twhen 7 then 'Contra Costa' \n\t\t\twhen 8 then 'Del Norte' \n\t\t\twhen 9 then 'El Dorado'\n\t\t\twhen 10 then 'Fresno'\n\t\t\twhen 11 then 'Glenn' \n\t\t\twhen 12 then 'Humboldt' \n\t\t\twhen 13 then 'Imperial' \n\t\t\twhen 14 then 'Inyo' \n\t\t\twhen 15 then 'Kern' \n\t\t\twhen 16 then 'Kings'\n\t\t\twhen 17 then 'Lake' \n\t\t\twhen 18 then 'Lassen' \n\t\t\twhen 19 then 'Los Angeles' \n\t\t\twhen 20 then 'Madera' \n\t\t\twhen 21 then 'Marin' \n\t\t\twhen 22 then 'Mariposa' \n\t\t\twhen 23 then 'Mendocino' \n\t\t\twhen 24 then 'Merced' \n\t\t\twhen 25 then 'Modoc' \n\t\t\twhen 26 then 'Mono' \n\t\t\twhen 27 then 'Monterey' \n\t\t\twhen 28 then 'Napa' \n\t\t\twhen 29 then 'Nevada'\n\t\t\twhen 30 then 'Orange'\n\t\t\twhen 31 then 'Placer'\n\t\t\twhen 32 then 'Plumas'\n\t\t\twhen 33 then 'Riverside'\n\t\t\twhen 34 then 'Sacramento'\n\t\t\twhen 35 then 'San Benito'\n\t\t\twhen 36 then 'San Bernardino'\n\t\t\twhen 37 then 'San Diego' \n\t\t\twhen 38 then 'San Francisco' \n\t\t\twhen 39 then 'San Joaquin'\n\t\t\twhen 40 then 'San Luis Obispo'\n\t\t\twhen 41 then 'San Mateo'\n\t\t\twhen 42 then 'Santa Barbara'\n\t\t\twhen 43 then 'Santa Clara'\n\t\t\twhen 44 then 'Santa Cruz'\n\t\t\twhen 45 then 'Shasta'\n\t\t\twhen 46 then 'Sierra'\n\t\t\twhen 47 then 'Siskiyou'\n\t\t\twhen 48 then 'Solano'\n\t\t\twhen 49 then 'Sonoma'\n\t\t\twhen 50 then 'Stanislaus'\n\t\t\twhen 51 then 'Sutter'\n\t\t\twhen 52 then 'Tehama'\n\t\t\twhen 53 then 'Trinity'\n\t\t\twhen 54 then 'Tulare'\n\t\t\twhen 55 then 'Tuolumne'\n\t\t\twhen 56 then 'Ventura'\n\t\t\twhen 57 then 'Yolo'\n\t\t\twhen 58 then 'Yuba'\n\t\t\telse self.to_s.squish.namerize\n\t\tend\n\tend",
"def read filename\n File.readlines(filename).each do |line|\n row = line.strip.split\n #determine which map type to use, state abbr. will always be 2 characters\n @type = row.first.length == 2 ? \"usa\" : \"counties\"\n counts[row.first] = row.last.to_i\n end\n end",
"def us_county?\n feature_code = featureCode.first\n parent_country = parentCountry.first\n sec_adm_level_code = 'www.geonames.org/ontology#A.ADM2'\n us_country_code = 'sws.geonames.org/6252001/'\n feature_code.respond_to?(:rdf_subject) && feature_code.rdf_subject.to_s.include?(sec_adm_level_code) && parent_country.respond_to?(:rdf_subject) && parent_country.rdf_subject.to_s.include?(us_country_code)\n end",
"def to_s\n county\n end",
"def set_county\n @county = County.find(params[:id])\n end",
"def set_county\n @county = County.find(params[:id])\n end",
"def set_county\n @county = County.find(params[:id])\n end",
"def show\n @county= County.find(params[:id])\n end",
"def get_entity_type\n return 'county'\n end",
"def institution_name\n @institution_name ||= File.read(file_path, :mode => \"rb\", :external_encoding => \"UTF-8\").strip\n rescue\n nil\n end",
"def getSpecialtyName(speciality_id)\n \tbegin\n \t\tspecialtyname = Clinicalsection.find(speciality_id).sectionname\n \trescue ActiveRecord::RecordNotFound => e\n \t\tspecialtyname = ''\n \tend\n return specialtyname\n end",
"def cities\n CS.get :us, :ca\n end",
"def stateCapitalDictionary()\n capHash = {}\n file = open('dictionaryTest.txt')\n file.each_line do |line|\n city, state = line.strip.split('|')\n capHash[state] = city\n end\n return capHash\nend",
"def process_countyzip_file(input_path)\n @import_timestamp = DateTime.now\n return Success(input_path) if @tenant.geographic_rating_area_model == 'single'\n\n params = { file: @county_zip_files.first, tenant: @tenant, year: @year, import_timestamp: @import_timestamp }\n cz_process_result = Transactions::CountyZipFile.new.call(params)\n if cz_process_result.success?\n Success(input_path)\n else\n destroy_countyzips(@tenant, @import_timestamp)\n Failure({errors: [\"Unable to create CountyZips/RatingArea for given counties per #{params[:file]}\"]})\n end\n end",
"def census\n GreatSchools::Census.for_school(state, id)\n end",
"def identifying_string\n @identifying_string ||= \"#{name}, Co. #{county}\"\n end",
"def create\n @county = County.new(params[:county])\n\n respond_to do |format|\n if @county.save\n format.html { redirect_to @county, notice: 'County was successfully created.' }\n format.json { render json: @county, status: :created, location: @county }\n else\n format.html { render action: \"new\" }\n format.json { render json: @county.errors, status: :unprocessable_entity }\n end\n end\n end",
"def rdf_label\n @label = super\n @label = Array(\"#{@label.first} County\") if us_county? && no_county_label\n\n unless valid_label\n return @label if top_level_element?\n\n @label = @label.first\n parent_hierarchy.each do |p|\n @label = \"#{@label.strip}, #{p.first.rdf_label.first}\"\n end\n end\n Array(@label)\n end",
"def create\n @county = County.new(params[:county])\n\n respond_to do |format|\n if @county.save\n flash[:notice] = 'County was successfully created.'\n format.html { redirect_to(@county) }\n format.xml { render :xml => @county, :status => :created, :location => @county }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @county.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def set_County(value)\n set_input(\"County\", value)\n end",
"def county_params\n params.fetch(:county, {})\n end",
"def load_surnames(src)\n parse_file(src, \"surname\")\n end",
"def lookup(city)\n puts $dial_book[city]\nend",
"def spanish_citizen_number; end",
"def initialize\n @cities = []\n @quantity = 0\n # Read Cities File\n read_file\n end",
"def county_params\n params.require(:county).permit(:geoid, :name, :statefp, :countyfp, :state_abbrev, :state_name, :latitude, :longitude)\n end",
"def court_division\n case(court)\n when \"superior\"\n \"Suffolk County Civil\"\n when /^bmc/\n court_name\n else\n \"N/A\"\n end\n end",
"def load_incomes(filename)\n File.readlines(filename).map(&:chomp).map(&:to_i)\n end",
"def show\n @county = County.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @county }\n end\n end",
"def get_counties\n @counseling = update_counseling(counseling_params)\n counties = State.find(params[:counseling][:work_state_abbrev]).counties rescue []\n\n update_session\n render :update do |page|\n page.replace_html \"counties\", :partial => \"county_selector\",\n :locals => {\n options: counties.collect { |c| [c.name, c.id] }.\n sort { |one, two| (one[0] == \"I don't know\" || two[0] == \"I don't know\") ? -1 : one[0] <=> two[0] },\n cities: params[:local]}\n page.visual_effect :highlight, 'county_container'\n end\n end",
"def campus_solutions_id\n @net_ldap_entry[:berkeleyeducsid].first\n end",
"def read_cities_from_input!\n file = nil\n\n if(ARGV[0] and not ARGV[0].empty?)\n file = File.open(ARGV[0], \"r\")\n else\n file = File.open(\"cities.txt\", \"r\")\n end\n\n file.each_with_index do |line, idx|\n line_ar = line.split(\"\\t\")\n #Loads each line into an object with a name and a location vector with latitude and longitude\n @@cities[idx] = {:name=>line_ar[0], :location=>Vector[line_ar[1].to_f, line_ar[2].to_f]}\n end\n end",
"def county_params\n params.require(:county).permit(:state_id, :county_name, :notes)\n end",
"def import_counties(options)\n import_places PlaceType::County, options\n end",
"def update\n @county = County.find(params[:id])\n\n respond_to do |format|\n if @county.update_attributes(params[:county])\n flash[:notice] = 'County was successfully updated.'\n format.html { redirect_to(@county) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @county.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def city\n fetch('world_cup.cities')\n end",
"def load_students(load_from_filename = STDIN.gets.chomp)\n if File.exist?(load_from_filename)\n CSV.read(load_from_filename).each do |line|\n name, cohort = line\n @students << {name: name, cohort: cohort.to_sym}\n end\n # puts \"Load the list from the file:\"\n # load_from_filename = STDIN.gets.chomp\n # File.open(load_from_filename, \"r\") { |file|\n # file.readlines.each do |line|\n # name, cohort = line.chomp.split(\",\")\n # @students << {name: name, cohort: cohort.to_sym} \n # end\n # }\n \n puts \"Loaded list of #{@students.count} students from #{load_from_filename}\"\n else # if given file doesn't exist\n puts \"Sorry, #{load_from_filename} doesn't exist\"\n exit # quit the program\n end\n\nend",
"def get_country\n @single_city_data[\"sys\"][\"country\"]\n end",
"def nationality\n get_attribute(Yoti::Attribute::NATIONALITY)\n end",
"def set_counseling\n @counseling = Counseling.find(params[:id])\n end",
"def get_header\n\theader = nil\n\tFile.open(\"./data/header.tex\",\"r\") do |f|\n\t\theader = f.readlines\n\tend\n\treturn header\n\t#パッケージの設定もここで入れれるといいんだが\nend",
"def us_county_beds(fips)\n state = us_county_to_state(fips).to_sym\n p_ratio = 1.0 * us_county_population(fips) / us_state_population(state)\n ret = us_state_beds(state)\n ret.each_key { |k| ret[k] = (ret[k] * p_ratio).round(1) }\n ret\n end",
"def update\n @county = County.find(params[:id])\n\n respond_to do |format|\n if @county.update_attributes(params[:county])\n format.html { redirect_to @county, notice: 'County was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @county.errors, status: :unprocessable_entity }\n end\n end\n end",
"def initialize iss_file, properties\n @iss_file = iss_file\n @name = properties['Name']\n end",
"def read_data_from_file\n file = File.read(\"condensed_capitals.json\")\n @countries_capitals_as_hash = JSON.parse(file)\n end",
"def state\n country = ISO3166::Country[country_residence]\n if country.try(:subdivisions?)\n country.subdivisions[state_code].try(:[], \"name\")\n else\n state_code\n end\n end",
"def getWord()\n\tFile.open(\"./corncob_lowercase.txt\"){|f|\n\t\tline=nil\n\t\trand(1..58110).times{line=f.gets}\n\t\tputs line\n\t\treturn line.chomp()\n\t}\nend",
"def read_search_term_file(file_name)\n file = File.open \"jobs/twitter_resources/#{file_name}.json\"\n data = JSON.load file\n file.close\n return data[\"search_terms\"]\nend",
"def get_word\n\t\tbegin\n\t\t File.readlines(DICTIONARY_FILENAME).\n\t\t select { |word| word.length.between?(6, 13) }.sample.chomp\n\t\trescue\n\t\t\tputs \"Unable to read from file '#{ DICTIONARY_FILENAME }'.\"\n\t\t\tnil\n\t\tend\n\tend",
"def spanish_foreign_citizen_number; end",
"def display_area_code(my_dial_book, city_name)\n area_code = my_dial_book[city_name]\n puts \"The Area code of #{city_name} is #{area_code}\"\nend",
"def get_country_name\n subdivision = Geonames::WebService.country_subdivision @latitude, @longitude\n subdivision.country_name\n end",
"def suffix\n fetch('university.suffix')\n end",
"def name\n return \"Canadian Add Unitary and Apply Standard\"\n end",
"def read_unicorns\n JSON.parse(File.read(\"unicorns.json\"))\nend",
"def get_csr\n # No op if its already done.\n gen_csr\n \n # Open the CSR file, which should exists after gen_csr.\n csr_str = \"\"\n File.open(@csr_file_path, \"r\") do |f|\n csr_str = f.read\n end\n\n return csr_str\n end",
"def get_faculty(affi_string)\n $affi_faculties.each do |faculty|\n if affi_string.include?(faculty)\n return faculty\n end\n end\n return nil\nend",
"def csz\n\t\t\"#{self.city}, #{self.state} #{self.zip}\"\n\tend",
"def load_sis_data_file( filename )\n\n sisdata = {}\n\n begin\n File.open( filename, 'r').each do |line|\n\n # handle blank and commented lines\n next if line.blank?\n next if line[ 0 ] == '#'\n tokens = line.strip.split( \"|\" )\n sisdata[ tokens[ 0 ] ] = tokens[ 1 ]\n end\n rescue Errno::ENOENT\n # do nothing, no file...\n end\n\n return sisdata\n\n end",
"def get_pop_for(state)\n # read the file to get the data\n read_file\n \n # create a new hash to store the requested informatiom\n @cities = Hash.new\n # populate the hash with file data\n @file_lines.each do |line|\n city, st, population = line.split(/\\t/)\n if state == st\n @cities[city] = population.chomp\n end\n end\n \n # print the output of the hash\n unless @cities.empty? \n puts \"Top Cities in #{state}\"\n puts \"=================\"\n @cities.sort{|a,b| a[0]<=>b[0]}.each do |city, population|\n puts \"#{city} (#{population})\"\n end\n else\n puts \"#{state} has no cities in the Top 40.\"\n end\n end",
"def load_students(filename = \"students.csv\")\n puts \"Enter file name to open:\"\n input_file = STDIN.gets.chomp\n input_file.empty? ? file = File.open(filename, \"r\") : file = File.open(input_file, \"r\") do |file|\n file.readlines.each do |line|\n name, cohort = line.chomp.split(\",\")\n @students << {name: name, cohort: cohort.to_sym}\n end\n end\n puts \"Your students have been loaded succesfully!\"\nend",
"def load_students(filename = \"students.csv\")\n file = File.open(filename, \"r\")\n file.readlines.each do |line|\n name, cohort = line.chomp.split(',') \n @students << {name: name, cohort: cohort.to_sym}\n end\n file.close\nend",
"def initialize(file)\n @data = { :students => [] }\n @file = file\n load_data\n end",
"def roster_county_params\n params.require(:roster_county).permit(:name, :county_code, :fips_code, :gis_name)\n end",
"def getSampleHeader()\n r = File.open(@communityFile, \"r\")\n @sampleHeader = r.gets.split(\"\\t\")[0]\n r.close()\n end",
"def load()\n\tFile.open(\"instructors.csv\", \"r\") { |f|\n\t\tdata = f.read()\n\t\treturn data\n\t}\nend",
"def initialize(securities_file, output_file)\n @file = securities_file\n @output = output_file ||= 'securities.txt'\n @securities = []\n @months = parse_months\n end",
"def property_display_address_street_comma_with_county\n dets = self['address_details']\n \"#{dets['address_line_1']}, #{dets['city']}, #{dets['county']} COUNTY, #{dets['state'][0..1]}, #{dets['zip_code']}\".upcase\n end",
"def load_students(filename = \"students.csv\")\n file = File.open(filename, \"r\")\n file.readlines.each do |line|\n name, cohort = line.chomp.split(\",\")\n @students << {name: name, cohort: cohort.to_sym}\n end\n file.close\nend",
"def load_students(filename)\n CSV.foreach(filename) do |line|\n name, cohort = line[0], line[1]\n add_to_students name, cohort #refactored\n end\n success\n #file.close\nend",
"def usa_driving_licence(state = 'California')\n bothify(fetch(\"driving_licence.usa.#{state.to_s.strip.downcase.gsub(' ', '_')}\"))\n rescue I18n::MissingTranslationData => _e\n raise InvalidStatePassed, \"Invalid state code passed for USA, '#{state}'\"\n end",
"def cl\n field_fetch('CL')\n end",
"def to_geo\n GeoIngredient.new('County', name: name, state: state, buffer: 0)\n end",
"def district\n parts[1]\n end",
"def percent_county_subdivision_land_area\n land_area / county_subdivision.land_area\n end",
"def company_code\n if self.yard.present? && self.yard.facility.present? && self.yard.facility.country.present?\n country = self.yard.facility.country\n \"COPART#{country.code}\".upcase\n else\n \"\"\n end\n end",
"def load_org_example name\n File.open(\"spec/data/org-file-#{name}.org\").read\nend",
"def reader_CN(file_name)\n type = \"CN\"\n num = 1\n printf(\"@I:read %s ... \",file_name)\n CSV.open(\"#{file_name}\",\"r\").each{|row|\n # Skip Header\n if row[0] == \"ProductName=\"\n obj = CSVHeaderInf.new\n @HeaderInf = obj.make(row)\n elsif /CN\\d-/ =~ row[0] || /\\d/ =~ row[0]\n# if row[0] != \"CN\"\n obj = CSVPinInf.new\n # Get Pin Information\n if obj.make(num,row,type) != nil\n @PinInf << obj.make(num,row,type) \n end\n# end\n end\n num += 1\n }\n printf(\"Success\\n\")\n return @HeaderInf,@PinInf\n end",
"def get_area_code(dial_book, city_name)\n # @type [String]\n area_code = ''\n\n # @type [String]\n normalized_city_name = normalize_city_name(city_name)\n\n dial_book.each_key do |city_name_dial|\n if normalize_city_name(city_name_dial) == normalized_city_name\n area_code = dial_book[city_name_dial]\n break\n end\n end\n\n area_code\nend",
"def country\n @country ||= IsoCountryCodes.find(alpha2)\n end",
"def pcode4\n school.sierra_code\n end",
"def read_tsp_file( file_name )\n file_path = File.join( TSP_DIR, \"#{file_name}.tsp\" )\n File.open( file_path ).read\nend",
"def sector_industry_label\n sector_name = industry.try(:sector).try(:name)\n industry_name = industry.try(:name)\n return \"\" unless industry_name && sector_name\n \"#{sector_name} / #{industry_name}\"\n end",
"def nationality; end",
"def test_identify_language_from_filename\n filename = 'one.fp'\n femp = Locale.new('femp', 'fp', 'fpt')\n curriculum.add(femp, %w(one two))\n assert_equal 'femp', curriculum.identify_language('femp.fp')\n end",
"def university; end",
"def download(county)\n puts \" F95BA #{county}\"\n results = @client.find :all, {\n class: '1', # 1 Residential\n query: \"(246=|A),(61=|#{county})\", #246 ListingStatus\n #A ActiveAvailable\n #61 County\n select: '157,881,10,922,924,137,261,129,246,80,61,25,1424,102,214,314,96,1,131,1329,sysid', \n search_type: 'Property'\n }\n puts \"F95BA #{results.size} listings\"\n #puts \"F95BA saving\"\n pg_save(results)\n results\n end",
"def cluster_name_by_file_type\n case study_file.file_type\n when 'Cluster'\n study_file.name\n when 'AnnData'\n params_object.name\n else\n nil\n end\n end",
"def load_students(filename = \"students.csv\")\n # CSV.open(filename, \"r\") {|file|\n CSV.foreach(filename) do |line| # contains name, cohort\n # file.readlines.each do |line|\n name, cohort = line\n student_into_array(name, cohort.to_sym)\n end\n\nend",
"def get_country(affi_string)\n cleared_affi_string = country_exclude(affi_string)\n $affi_countries.each do |country|\n if cleared_affi_string.include?(country)\n return country\n end\n end\n return nil\nend",
"def plist name\n File.open(File.dirname(__FILE__) + \"/plist/#{name}.plist\").read\nend",
"def percent_county_subdivision_total_area\n total_area / county_subdivision.total_area\n end",
"def initialize(filename)\n @joltages = IO.readlines(filename).map(&:to_i).sort\n @counts = {}\n end",
"def co\n field_fetch('CO')\n end",
"def capital_city\n fetch('nation.capital_city')\n end",
"def get_area_code(hashbook, city)\n hashbook[city]\nend",
"def census\n # @census ||= JSON.parse(::HTTPClient.get(\"#{@opts[:url]}:9631/census\").body)\n @census ||= JSON.parse(inspec.http(\"#{@opts[:url]}:9631/census\").body)\n end",
"def showCityName(city)\n puts \"Your requested area code is: #{$dial_book[city]}\"\nend",
"def step3g_fluctuation_source(path)\n return \"#{path.pathmap('%d')}/nreads.RData\"\nend"
] |
[
"0.6126817",
"0.5840096",
"0.5806407",
"0.57190007",
"0.5713216",
"0.56970817",
"0.56970817",
"0.56970817",
"0.5654555",
"0.5235436",
"0.51854503",
"0.5128856",
"0.50996417",
"0.50856274",
"0.5079576",
"0.49857908",
"0.49810976",
"0.49487928",
"0.49149308",
"0.49089268",
"0.489476",
"0.48851818",
"0.48743182",
"0.48407894",
"0.48321822",
"0.4828768",
"0.48280254",
"0.48257706",
"0.48189512",
"0.48099673",
"0.48075417",
"0.47696677",
"0.47394156",
"0.47376117",
"0.47361824",
"0.47237328",
"0.47107774",
"0.47105625",
"0.47102243",
"0.470997",
"0.46903655",
"0.4683772",
"0.4672287",
"0.46676394",
"0.4667489",
"0.4663556",
"0.4657373",
"0.465664",
"0.46500826",
"0.46450067",
"0.46323436",
"0.46213412",
"0.46196455",
"0.46093157",
"0.4600317",
"0.4598615",
"0.45964423",
"0.45946473",
"0.45913914",
"0.4579488",
"0.45629942",
"0.45524094",
"0.45447624",
"0.4525015",
"0.4524914",
"0.45202276",
"0.45171547",
"0.45158574",
"0.45155677",
"0.45131782",
"0.45119235",
"0.45009676",
"0.4494652",
"0.4492521",
"0.4489708",
"0.44872066",
"0.44861653",
"0.4480178",
"0.4478445",
"0.44778004",
"0.4477341",
"0.44745964",
"0.44730827",
"0.4468564",
"0.44647977",
"0.44578427",
"0.44549686",
"0.4448226",
"0.44433746",
"0.44390237",
"0.44385245",
"0.44376418",
"0.4432592",
"0.44311568",
"0.44293845",
"0.44267476",
"0.44258416",
"0.44223207",
"0.4416135",
"0.44135702"
] |
0.6615666
|
0
|
Returns the country described in the file Example: >> my_well = CWLSLas.new('my_well.las') => >> my_well.country => "US"
|
def country
self.well_info.country
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def country\n @country ||= IsoCountryCodes.find(alpha2)\n end",
"def get_country\n @single_city_data[\"sys\"][\"country\"]\n end",
"def country\n self[:C]\n end",
"def country\n 'United Kingdom'\n end",
"def get_country_name_lib country_code\n country = Carmen::Country.coded(country_code)\n if country\n country.name\n else\n \"N/A\"\n end\n end",
"def country\n data['country']\n end",
"def country\n location[2] || location[1]\n end",
"def country\n @country ||= begin\n valid_countries.find do |iso2|\n @data[iso2][Core::MAIN_COUNTRY_FOR_CODE] == 'true'\n end || valid_countries.first || countries.first\n end\n end",
"def country\n 'Australia'\n end",
"def country\n if(@country_code.to_i == 280)\n IsoCountryCodes.find(276) #since 1990 we use 176 for whole germany, 280 was for \"west germany\" WTF\n else\n IsoCountryCodes.find(@country_code)\n end\n end",
"def country\n ISO3166::Country[@country_code]\n end",
"def country\n \tself.contry\n end",
"def country_name\n country = ISO3166::Country[country_code]\n # country.translations[I18n.locale.to_s] || country.name\n # country.name\n end",
"def country\n @country ||= I18n.default_locale\n end",
"def country\n RAILS_DEFAULT_LOGGER.debug(\"profile.country -- returning #{setting(:company_country)}\")\n \n setting(:company_country).to_s\n end",
"def user_country\n USER_COUNTRY[country]\n end",
"def country_name\n ISO3166::Country[country_code].name if country_code.present?\n end",
"def country_name\n countryfull = ISO3166::Country[country]\n countryfull.translations[I18n.locale.to_s] || countryfull.name\n end",
"def country_name\n cc = carmen_country\n\n cc ? \"#{cc.name}\" : ''\n end",
"def country_name(multilingual = false)\n if self.country\n country_data = ISO3166::Country[self.country]\n\t\t\tif country_data and multilingual\n\t\t\t country_data.translations[I18n.locale.to_s] || country_data.name\n\t\t\telsif country_data\n\t\t\t country_data.name\n\t\t\telse\n\t\t\t self.country\n\t\t\tend\n else\n \"\"\n end\n end",
"def get_country_name\n subdivision = Geonames::WebService.country_subdivision @latitude, @longitude\n subdivision.country_name\n end",
"def country; end",
"def country; end",
"def country; end",
"def country\n @country || @default_country || 'GB'\n end",
"def carmen_country\n return unless country.is_a?(String)\n\n Carmen::Country.named(country) || Carmen::Country.coded(country)\n end",
"def country()\n country = Country.find_by_id(@country_id)\n return country\n end",
"def get_country_codes\n content = File.read(\"public/ssp/country_code.txt\")\n country_codes = Hash.new\n content.split(\":\").each do |country_code |\n cc = country_code.split(\",\")\n if cc.size == 2 \n country_codes[cc[0]] = cc[1]\n end\n end\n return country_codes\n end",
"def country\n client.places.get_countries.select{|hash| hash[\"cid\"] == @params[:country].to_i}.first[:title]\n end",
"def country_name\n iso_country = ISO3166::Country[country] # `country` should be code like 'AU'\n iso_country.translations[I18n.locale.to_s] || iso_country.name\n end",
"def country(code, name); end",
"def country_name\n country = ISO3166::Country[country_code]\n country.translations[I18n.locale.to_s] || country.name\n end",
"def country_name\n country = ISO3166::Country[country_code]\n country.translations[I18n.locale.to_s] || country.name\n end",
"def country_name\n country = ISO3166::Country[country_code]\n country.translations[I18n.locale.to_s] || country.name\n end",
"def country\n params['country']\n end",
"def find_language\r\n #Find the language based on the path\r\n PropertyFileAttributes::LOCALES.each do |l|\r\n if @filename.index(l)\r\n @language = l\r\n end\r\n end\r\n #If the language is not indicated assume it is English\r\n if @language == nil\r\n @language = PropertyFileAttributes::LOCALES[0] #\"Default\"\r\n end\r\n end",
"def country(opts = {})\n data, _status_code, _headers = country_with_http_info(opts)\n data\n end",
"def country\n @country\n end",
"def institution_name\n @institution_name ||= File.read(file_path, :mode => \"rb\", :external_encoding => \"UTF-8\").strip\n rescue\n nil\n end",
"def country_to_culture\n @country_to_culture ||= begin\n result = {}\n glob(\"history/countries/*.txt\").each do |path|\n tag = path.basename.to_s[0,3]\n node = parse(path)\n result[tag] = node[\"primary_culture\"]\n end\n result\n end\n end",
"def get_country(affi_string)\n cleared_affi_string = country_exclude(affi_string)\n $affi_countries.each do |country|\n if cleared_affi_string.include?(country)\n return country\n end\n end\n return nil\nend",
"def load_country_info(code)\n info = @country_index[code]\n raise InvalidCountryCode, 'Invalid country code' unless info\n info\n end",
"def represented_country; end",
"def country_name(country_code)\n country = ISO3166::Country[country_code]\n country.name\n end",
"def best_guess_at_country\n return self.country if !self.country.nil?\n\n extension_possibilities = []\n extension_possibilities << \".#{self.uri.to_s.gsub(/^.+organisations\\/.+\\-/, '')}\"\n extension_possibilities << self.uri.to_s.gsub(/^.+organisations\\/[A-z]+/, '').gsub(/\\-/, '.')\n extension_possibilities << self.uri.to_s.match(/\\-[A-z]+\\-[A-z]+$/)[0].gsub(/\\-/, '.') rescue ''\n mapping = ArtsAPI::COUNTRIES_MAPPING\n\n result = nil\n extension_possibilities.each { |ex| result = mapping[ex] if mapping.has_key?(ex) }\n\n if !result.nil?\n self.country = result\n self.save\n end\n\n result\n end",
"def language_in(country_name)\n params = {query: {fullText: 'true'}}\n response = HTTParty.get(\"#{COUNTRIES_BASE_URL}/#{country_name}\", params)\n json_response = JSON.parse(response.body)\n json_response.first['languages'].first['iso639_1']\n end",
"def language_in(country_name)\n params = {query: {fullText: 'true'}}\n response = HTTParty.get(\"#{COUNTRIES_BASE_URL}/#{country_name}\", params)\n json_response = JSON.parse(response.body)\n json_response.first['languages'].first['iso639_1']\n end",
"def language_in(country_name)\n params = {query: {fullText: 'true'}}\n response = HTTParty.get(\"#{COUNTRIES_BASE_URL}/#{country_name}\", params)\n json_response = JSON.parse(response.body)\n json_response.first['languages'].first['iso639_1']\n end",
"def language_in(country_name)\n params = {query: {fullText: 'true'}}\n response = HTTParty.get(\"#{COUNTRIES_BASE_URL}/#{country_name}\", params)\n json_response = JSON.parse(response.body)\n json_response.first['languages'].first['iso639_1']\n end",
"def language_in(country_name)\n params = {query: {fullText: 'true'}}\n response = HTTParty.get(\"#{COUNTRIES_BASE_URL}/#{country_name}\", params)\n json_response = JSON.parse(response.body)\n json_response.first['languages'].first['iso639_1']\n end",
"def language_in(country_name)\n params = {query: {fullText: 'true'}}\n response = HTTParty.get(\"#{COUNTRIES_BASE_URL}/#{country_name}\", params)\n json_response = JSON.parse(response.body)\n json_response.first['languages'].first['iso639_1']\n end",
"def language_in(country_name)\n params = {query: {fullText: 'true'}}\n response = HTTParty.get(\"#{COUNTRIES_BASE_URL}/#{country_name}\", params)\n json_response = JSON.parse(response.body)\n json_response.first['languages'].first['iso639_1']\n end",
"def language_in(country_name)\n params = {query: {fullText: 'true'}}\n response = HTTParty.get(\"#{COUNTRIES_BASE_URL}/#{country_name}\", params)\n json_response = JSON.parse(response.body)\n json_response.first['languages'].first['iso639_1']\n end",
"def language_in(country_name)\n params = {query: {fullText: 'true'}}\n response = HTTParty.get(\"#{COUNTRIES_BASE_URL}/#{country_name}\", params)\n json_response = JSON.parse(response.body)\n json_response.first['languages'].first['iso639_1']\n end",
"def import_countries(file)\n Country.transaction do\n while (line = file.gets)\n next if line.match(/^#/)\n line = line.split(/\\t/)\n \n c = Country.create(\n :iso2 => line[0], :iso3 => line[1], :ison => line[2],\n :name => line[4], :capital => line[5], :area => line[6],\n :continent => line[8], :currency_code => line[10], :currency_name => line[11],\n :phone => line[12], :geoname_id => line[16]\n )\n @@countries[line[0]] = c.id\n end\n end\n end",
"def get_country_name( code )\n # Strip and lowercase code\n new_code = code.strip.downcase\n # Find country by code. If not found, default to empty string.\n country = $COUNTRIES.find do |record|\n record[:code] == new_code.downcase\n end || ''\n\n return country.length > 0 ? \"The country you selected is #{country[:name]}.\" :\n 'That country code is not in our database.'\nend",
"def load_country_code(sections)\n # For now we assume all phone numbers are USA centric. If we wish to support other country\n # codes in the future we will need to enforce the presence of a country code when entering\n # a phone number\n return USA unless sections.first.length == 1\n\n raise \"Unsupported Country Code\" unless COUNTRY_CODES.include?(sections.first)\n\n sections.shift\n end",
"def get_country_name country_code\n country = Country.find(\n :first,\n :conditions => [\"LOWER(Code) = ?\", country_code]\n )\n if country\n country.Name\n else\n \"N/A\"\n end\n end",
"def guess_country\n warnings = Array.new\n\n country_name = country\n residence_name = residence\n\n if country_name && country_name.length > 2\n self.country = lookup_isocode(country_name)\n warnings << \"Country of origin #{country_name} is not in ISO directory\" unless country\n end\n\n if residence_name && residence_name.length > 2\n self.residence = lookup_isocode(residence_name)\n warnings << \"Country of residence #{residence_name} is not in ISO directory\" unless residence\n end\n\n return warnings\n end",
"def country(hostname)\n case @database_type\n when Edition::CITY_REV0, Edition::CITY_REV1, Edition::CITY_REV1_V6\n city(hostname)\n\n when Edition::REGION_REV0, Edition::REGION_REV1\n region(hostname)\n\n when Edition::NETSPEED, Edition::NETSPEED_REV1\n netspeed(hostname)\n\n when Edition::COUNTRY, Edition::PROXY, Edition::COUNTRY_V6\n ip = lookup_ip(hostname)\n if @ip_bits > 32\n\tipaddr = IPAddr.new ip\n\tcode = (seek_record(ipaddr.to_i) - COUNTRY_BEGIN)\n else\n\t# Convert numeric IP address to an integer\n\tipnum = iptonum(ip)\n\tcode = (seek_record(ipnum) - @database_segments[0])\n end\n read_country(code, hostname, ip)\n else\n throw \"Invalid GeoIP database type #{@database_type}, can't look up Country by IP\"\n end\n end",
"def countries(data)\n my_hash = JSON.parse(data)\n conv_name = my_hash[0]['conventional_short_form']\n puts conv_name\nend",
"def test_identify_language_from_filename\n filename = 'one.fp'\n femp = Locale.new('femp', 'fp', 'fpt')\n curriculum.add(femp, %w(one two))\n assert_equal 'femp', curriculum.identify_language('femp.fp')\n end",
"def format_country(country)\n return country if country == '' || country == 'Global'\n\n begin\n IsoCountryCodes.find(country).name\n rescue\n # Fallback to raw value\n country\n end\n end",
"def country\n query_root_node(\"gdacs:country/text()\", @@NAMESPACES)\n end",
"def country=(value)\n @country = value\n\n @format = case country_code\n when nil, '' then nil\n else LocalPostal::Format.from_country_code(country_code)\n end\n end",
"def country_code\n cc = carmen_country\n\n cc ? \"#{cc.code.upcase}\" : nil\n end",
"def country_code; end",
"def country_code; end",
"def country_code\n end",
"def country\n city.country\n end",
"def country(code)\n\t\tcase code\n\t\t\twhen \"AD\"\tthen \"Andorra\"\n\t\t\twhen \"AE\"\tthen \"United Arab Emirates\"\n\t\t\twhen \"AF\"\tthen \"Afghanistan\"\n\t\t\twhen \"AG\"\tthen \"Antigua and Barbuda\"\n\t\t\twhen \"AI\"\tthen \"Anguilla\"\n\t\t\twhen \"AL\"\tthen \"Albania\"\n\t\t\twhen \"AM\"\tthen \"Armenia\"\n\t\t\twhen \"AO\"\tthen \"Angola\"\n\t\t\twhen \"AR\"\tthen \"Argentina\"\n\t\t\twhen \"AS\"\tthen \"American Samoa\"\n\t\t\twhen \"AT\"\tthen \"Austria\"\n\t\t\twhen \"AU\"\tthen \"Australia\"\n\t\t\twhen \"AW\"\tthen \"Aruba\"\n\t\t\twhen \"AX\"\tthen \"Aland Islands\"\n\t\t\twhen \"AZ\"\tthen \"Azerbaijan\"\n\t\t\twhen \"BA\"\tthen \"Bosnia and Herzegovina\"\n\t\t\twhen \"BB\"\tthen \"Barbados\"\n\t\t\twhen \"BD\"\tthen \"Bangladesh\"\n\t\t\twhen \"BE\"\tthen \"Belgium\"\n\t\t\twhen \"BF\"\tthen \"Burkina Faso\"\n\t\t\twhen \"BG\"\tthen \"Bulgaria\"\n\t\t\twhen \"BH\"\tthen \"Bahrain\"\n\t\t\twhen \"BI\"\tthen \"Burundi\"\n\t\t\twhen \"BJ\"\tthen \"Benin\"\n\t\t\twhen \"BL\"\tthen \"Saint Barthelemy\"\n\t\t\twhen \"BN\"\tthen \"Brunei Darussalam\"\n\t\t\twhen \"BO\"\tthen \"Bolivia\"\n\t\t\twhen \"BM\"\tthen \"Bermuda\"\n\t\t\twhen \"BQ\"\tthen \"Bonaire Saint Eustachius and Saba\"\n\t\t\twhen \"BR\"\tthen \"Brazil\"\n\t\t\twhen \"BS\"\tthen \"Bahamas\"\n\t\t\twhen \"BT\"\tthen \"Bhutan\"\n\t\t\twhen \"BV\"\tthen \"Bouvet Island\"\n\t\t\twhen \"BW\"\tthen \"Botswana\"\n\t\t\twhen \"BY\"\tthen \"Belarus\"\n\t\t\twhen \"BZ\"\tthen \"Belize\"\n\t\t\twhen \"CA\"\tthen \"Canada\"\n\t\t\twhen \"CC\"\tthen \"Cocos (Keeling) Islands\"\n\t\t\twhen \"CD\"\tthen \"Democratic Republic of Congo\"\n\t\t\twhen \"CF\"\tthen \"Central African Republic\"\n\t\t\twhen \"CG\"\tthen \"Republic of Congo\"\n\t\t\twhen \"CH\"\tthen \"Switzerland\"\n\t\t\twhen \"CI\"\tthen \"Côte d'Ivoire\"\n\t\t\twhen \"CK\"\tthen \"Cook Islands\"\n\t\t\twhen \"CL\"\tthen \"Chile\"\n\t\t\twhen \"CM\"\tthen \"Cameroon\"\n\t\t\twhen \"CN\"\tthen \"China\"\n\t\t\twhen \"CO\"\tthen \"Colombia\"\n\t\t\twhen \"CR\"\tthen \"Costa Rica\"\n\t\t\twhen \"CU\"\tthen \"Cuba\"\n\t\t\twhen \"CV\"\tthen \"Cape Verde\"\n\t\t\twhen \"CW\"\tthen \"Curaçao\"\n\t\t\twhen \"CX\"\tthen \"Christmas Island\"\n\t\t\twhen \"CY\"\tthen \"Cyprus\"\n\t\t\twhen \"CZ\"\tthen \"Czech Republic\"\n\t\t\twhen \"DE\"\tthen \"Germany\"\n\t\t\twhen \"DJ\"\tthen \"Djibouti\"\n\t\t\twhen \"DK\"\tthen \"Denmark\"\n\t\t\twhen \"DM\"\tthen \"Dominica\"\n\t\t\twhen \"DO\"\tthen \"Dominican Republic\"\n\t\t\twhen \"DZ\"\tthen \"Algeria\"\n\t\t\twhen \"EC\"\tthen \"Ecuador\"\n\t\t\twhen \"EG\"\tthen \"Egypt\"\n\t\t\twhen \"EE\"\tthen \"Estonia\"\n\t\t\twhen \"EH\"\tthen \"Western Sahara\"\n\t\t\twhen \"ER\"\tthen \"Eritrea\"\n\t\t\twhen \"ES\"\tthen \"Spain\"\n\t\t\twhen \"ET\"\tthen \"Ethiopia\"\n\t\t\twhen \"FI\"\tthen \"Finland\"\n\t\t\twhen \"FJ\"\tthen \"Fiji\"\n\t\t\twhen \"FK\"\tthen \"Falkland Islands\"\n\t\t\twhen \"FM\"\tthen \"Federated States of Micronesia\"\n\t\t\twhen \"FO\"\tthen \"Faroe Islands\"\n\t\t\twhen \"FR\"\tthen \"France\"\n\t\t\twhen \"GA\"\tthen \"Gabon\"\n\t\t\twhen \"GB\"\tthen \"United Kingdom\"\n\t\t\twhen \"GE\"\tthen \"Georgia\"\n\t\t\twhen \"GD\"\tthen \"Grenada\"\n\t\t\twhen \"GF\"\tthen \"French Guiana\"\n\t\t\twhen \"GG\"\tthen \"Guernsey\"\n\t\t\twhen \"GH\"\tthen \"Ghana\"\n\t\t\twhen \"GI\"\tthen \"Gibraltar\"\n\t\t\twhen \"GL\"\tthen \"Greenland\"\n\t\t\twhen \"GM\"\tthen \"Gambia\"\n\t\t\twhen \"GN\"\tthen \"Guinea\"\n\t\t\twhen \"GO\"\tthen \"Glorioso Islands\"\n\t\t\twhen \"GP\"\tthen \"Guadeloupe\"\n\t\t\twhen \"GQ\"\tthen \"Equatorial Guinea\"\n\t\t\twhen \"GR\"\tthen \"Greece\"\n\t\t\twhen \"GS\"\tthen \"South Georgia and South Sandwich Islands\"\n\t\t\twhen \"GT\"\tthen \"Guatemala\"\n\t\t\twhen \"GU\"\tthen \"Guam\"\n\t\t\twhen \"GW\"\tthen \"Guinea-Bissau\"\n\t\t\twhen \"GY\"\tthen \"Guyana\"\n\t\t\twhen \"HK\"\tthen \"Hong Kong\"\n\t\t\twhen \"HM\"\tthen \"Heard Island and McDonald Islands\"\n\t\t\twhen \"HN\"\tthen \"Honduras\"\n\t\t\twhen \"HR\"\tthen \"Croatia\"\n\t\t\twhen \"HT\"\tthen \"Haiti\"\n\t\t\twhen \"HU\"\tthen \"Hungary\"\n\t\t\twhen \"ID\"\tthen \"Indonesia\"\n\t\t\twhen \"IE\"\tthen \"Ireland\"\n\t\t\twhen \"IL\"\tthen \"Israel\"\n\t\t\twhen \"IM\"\tthen \"Isle of Man\"\n\t\t\twhen \"IN\"\tthen \"India\"\n\t\t\twhen \"IO\"\tthen \"British Indian Ocean Territory\"\n\t\t\twhen \"IQ\"\tthen \"Iraq\"\n\t\t\twhen \"IR\"\tthen \"Iran\"\n\t\t\twhen \"IS\"\tthen \"Iceland\"\n\t\t\twhen \"IT\"\tthen \"Italy\"\n\t\t\twhen \"JE\"\tthen \"Jersey\"\n\t\t\twhen \"JM\"\tthen \"Jamaica\"\n\t\t\twhen \"JO\"\tthen \"Jordan\"\n\t\t\twhen \"JP\"\tthen \"Japan\"\n\t\t\twhen \"JU\"\tthen \"Juan De Nova Island\"\n\t\t\twhen \"KE\"\tthen \"Kenya\"\n\t\t\twhen \"KG\"\tthen \"Kyrgyzstan\"\n\t\t\twhen \"KH\"\tthen \"Cambodia\"\n\t\t\twhen \"KI\"\tthen \"Kiribati\"\n\t\t\twhen \"KM\"\tthen \"Comoros\"\n\t\t\twhen \"KN\"\tthen \"Saint Kitts and Nevis\"\n\t\t\twhen \"KP\"\tthen \"North Korea\"\n\t\t\twhen \"KR\"\tthen \"South Korea\"\n\t\t\twhen \"XK\"\tthen \"Kosovo\"\n\t\t\twhen \"KW\"\tthen \"Kuwait\"\n\t\t\twhen \"KY\"\tthen \"Cayman Islands\"\n\t\t\twhen \"KZ\"\tthen \"Kazakhstan\"\n\t\t\twhen \"LA\"\tthen \"Lao People's Democratic Republic\"\n\t\t\twhen \"LB\"\tthen \"Lebanon\"\n\t\t\twhen \"LC\"\tthen \"Saint Lucia\"\n\t\t\twhen \"LI\"\tthen \"Liechtenstein\"\n\t\t\twhen \"LK\"\tthen \"Sri Lanka\"\n\t\t\twhen \"LR\"\tthen \"Liberia\"\n\t\t\twhen \"LS\"\tthen \"Lesotho\"\n\t\t\twhen \"LT\"\tthen \"Lithuania\"\n\t\t\twhen \"LU\"\tthen \"Luxembourg\"\n\t\t\twhen \"LV\"\tthen \"Latvia\"\n\t\t\twhen \"LY\"\tthen \"Libya\"\n\t\t\twhen \"MA\"\tthen \"Morocco\"\n\t\t\twhen \"MC\"\tthen \"Monaco\"\n\t\t\twhen \"MD\"\tthen \"Moldova\"\n\t\t\twhen \"MG\"\tthen \"Madagascar\"\n\t\t\twhen \"ME\"\tthen \"Montenegro\"\n\t\t\twhen \"MF\"\tthen \"Saint Martin\"\n\t\t\twhen \"MH\"\tthen \"Marshall Islands\"\n\t\t\twhen \"MK\"\tthen \"Macedonia\"\n\t\t\twhen \"ML\"\tthen \"Mali\"\n\t\t\twhen \"MO\"\tthen \"Macau\"\n\t\t\twhen \"MM\"\tthen \"Myanmar\"\n\t\t\twhen \"MN\"\tthen \"Mongolia\"\n\t\t\twhen \"MP\"\tthen \"Northern Mariana Islands\"\n\t\t\twhen \"MQ\"\tthen \"Martinique\"\n\t\t\twhen \"MR\"\tthen \"Mauritania\"\n\t\t\twhen \"MS\"\tthen \"Montserrat\"\n\t\t\twhen \"MT\"\tthen \"Malta\"\n\t\t\twhen \"MU\"\tthen \"Mauritius\"\n\t\t\twhen \"MV\"\tthen \"Maldives\"\n\t\t\twhen \"MW\"\tthen \"Malawi\"\n\t\t\twhen \"MX\"\tthen \"Mexico\"\n\t\t\twhen \"MY\"\tthen \"Malaysia\"\n\t\t\twhen \"MZ\"\tthen \"Mozambique\"\n\t\t\twhen \"NA\"\tthen \"Namibia\"\n\t\t\twhen \"NC\"\tthen \"New Caledonia\"\n\t\t\twhen \"NE\"\tthen \"Niger\"\n\t\t\twhen \"NF\"\tthen \"Norfolk Island\"\n\t\t\twhen \"NG\"\tthen \"Nigeria\"\n\t\t\twhen \"NI\"\tthen \"Nicaragua\"\n\t\t\twhen \"NL\"\tthen \"Netherlands\"\n\t\t\twhen \"NO\"\tthen \"Norway\"\n\t\t\twhen \"NP\"\tthen \"Nepal\"\n\t\t\twhen \"NR\"\tthen \"Nauru\"\n\t\t\twhen \"NU\"\tthen \"Niue\"\n\t\t\twhen \"NZ\"\tthen \"New Zealand\"\n\t\t\twhen \"OM\"\tthen \"Oman\"\n\t\t\twhen \"PA\"\tthen \"Panama\"\n\t\t\twhen \"PE\"\tthen \"Peru\"\n\t\t\twhen \"PF\"\tthen \"French Polynesia\"\n\t\t\twhen \"PG\"\tthen \"Papua New Guinea\"\n\t\t\twhen \"PH\"\tthen \"Philippines\"\n\t\t\twhen \"PK\"\tthen \"Pakistan\"\n\t\t\twhen \"PL\"\tthen \"Poland\"\n\t\t\twhen \"PM\"\tthen \"Saint Pierre and Miquelon\"\n\t\t\twhen \"PN\"\tthen \"Pitcairn Islands\"\n\t\t\twhen \"PR\"\tthen \"Puerto Rico\"\n\t\t\twhen \"PS\"\tthen \"Palestinian Territories\"\n\t\t\twhen \"PT\"\tthen \"Portugal\"\n\t\t\twhen \"PW\"\tthen \"Palau\"\n\t\t\twhen \"PY\"\tthen \"Paraguay\"\n\t\t\twhen \"QA\"\tthen \"Qatar\"\n\t\t\twhen \"RE\"\tthen \"Reunion\"\n\t\t\twhen \"RO\"\tthen \"Romania\"\n\t\t\twhen \"RS\"\tthen \"Serbia\"\n\t\t\twhen \"RU\"\tthen \"Russia\"\n\t\t\twhen \"RW\"\tthen \"Rwanda\"\n\t\t\twhen \"SA\"\tthen \"Saudi Arabia\"\n\t\t\twhen \"SB\"\tthen \"Solomon Islands\"\n\t\t\twhen \"SC\"\tthen \"Seychelles\"\n\t\t\twhen \"SD\"\tthen \"Sudan\"\n\t\t\twhen \"SE\"\tthen \"Sweden\"\n\t\t\twhen \"SG\"\tthen \"Singapore\"\n\t\t\twhen \"SH\"\tthen \"Saint Helena\"\n\t\t\twhen \"SI\"\tthen \"Slovenia\"\n\t\t\twhen \"SJ\"\tthen \"Svalbard and Jan Mayen\"\n\t\t\twhen \"SK\"\tthen \"Slovakia\"\n\t\t\twhen \"SL\"\tthen \"Sierra Leone\"\n\t\t\twhen \"SM\"\tthen \"San Marino\"\n\t\t\twhen \"SN\"\tthen \"Senegal\"\n\t\t\twhen \"SO\"\tthen \"Somalia\"\n\t\t\twhen \"SR\"\tthen \"Suriname\"\n\t\t\twhen \"SS\"\tthen \"South Sudan\"\n\t\t\twhen \"ST\"\tthen \"Sao Tome and Principe\"\n\t\t\twhen \"SV\"\tthen \"El Salvador\"\n\t\t\twhen \"SX\"\tthen \"Saint Martin\"\n\t\t\twhen \"SY\"\tthen \"Syria\"\n\t\t\twhen \"SZ\"\tthen \"Swaziland\"\n\t\t\twhen \"TC\"\tthen \"Turks and Caicos Islands\"\n\t\t\twhen \"TD\"\tthen \"Chad\"\n\t\t\twhen \"TF\"\tthen \"French Southern and Antarctic Lands\"\n\t\t\twhen \"TG\"\tthen \"Togo\"\n\t\t\twhen \"TH\"\tthen \"Thailand\"\n\t\t\twhen \"TJ\"\tthen \"Tajikistan\"\n\t\t\twhen \"TK\"\tthen \"Tokelau\"\n\t\t\twhen \"TL\"\tthen \"Timor-Leste\"\n\t\t\twhen \"TM\"\tthen \"Turkmenistan\"\n\t\t\twhen \"TN\"\tthen \"Tunisia\"\n\t\t\twhen \"TO\"\tthen \"Tonga\"\n\t\t\twhen \"TR\"\tthen \"Turkey\"\n\t\t\twhen \"TT\"\tthen \"Trinidad and Tobago\"\n\t\t\twhen \"TV\"\tthen \"Tuvalu\"\n\t\t\twhen \"TW\"\tthen \"Taiwan\"\n\t\t\twhen \"TZ\"\tthen \"Tanzania\"\n\t\t\twhen \"UA\"\tthen \"Ukraine\"\n\t\t\twhen \"UG\"\tthen \"Uganda\"\n\t\t\twhen \"UM_DQ\"\tthen \"Jarvis Island\"\n\t\t\twhen \"UM_FQ\"\tthen \"Baker Island\"\n\t\t\twhen \"UM_HQ\"\tthen \"Howland Island\"\n\t\t\twhen \"UM_JQ\"\tthen \"Johnston Atoll\"\n\t\t\twhen \"UM_MQ\"\tthen \"Midway Islands\"\n\t\t\twhen \"UM_WQ\"\tthen \"Wake Island\"\n\t\t\twhen \"US\"\tthen \"United States\"\n\t\t\twhen \"UY\"\tthen \"Uruguay\"\n\t\t\twhen \"UZ\"\tthen \"Uzbekistan\"\n\t\t\twhen \"VA\"\tthen \"Vatican City\"\n\t\t\twhen \"VC\"\tthen \"Saint Vincent and the Grenadines\"\n\t\t\twhen \"VE\"\tthen \"Venezuela\"\n\t\t\twhen \"VG\"\tthen \"British Virgin Islands\"\n\t\t\twhen \"VI\"\tthen \"US Virgin Islands\"\n\t\t\twhen \"VN\"\tthen \"Vietnam\"\n\t\t\twhen \"VU\"\tthen \"Vanuatu\"\n\t\t\twhen \"WF\"\tthen \"Wallis and Futuna\"\n\t\t\twhen \"WS\"\tthen \"Samoa\"\n\t\t\twhen \"YE\"\tthen \"Yemen\"\n\t\t\twhen \"YT\"\tthen \"Mayotte\"\n\t\t\twhen \"ZA\"\tthen \"South Africa\"\n\t\t\twhen \"ZM\"\tthen \"Zambia\"\n\t\t\twhen \"ZW\"\tthen \"Zimbabwe\"\n\t\t\telse\n\t\t\t\t\"ERROR\"\n\t\tend\n\tend",
"def countries\n document[\"nationality\"].collect {|nation| nation[\"$\"]} rescue nil\n end",
"def language\n fetch('nation.language')\n end",
"def find_country\n\t @country = Country.get(params[:country_id])\n\tend",
"def find_country\n\t @country = Country.get(params[:country_id])\n\tend",
"def load_country_info(code)\n raise_invalid_data_source('load_country_info')\n end",
"def country_code\n return @country_code\n end",
"def country=(value)\n\t\t\t@country = value\n\t\tend",
"def get_country(str)\n data = check_local_db(str)\n\n if data.nil? \n data = Geocoder.search(str)\n\n #has to parse through geocode data to find correct result\n data.first.address_components.each do |obj|\n data = obj[\"short_name\"] if obj[\"types\"][0] == \"country\"\n end\n\n save_to_db(str, data)\n end\n\n return data\n end",
"def get_iso_country(country)\n #Kinda redundant but downcasing first makes the hardcoding a bit more obvious\n country = country.downcase\n\n if country == \"bosnia-herzogovnia\"\n country = \"bosnia and herzogovnia\"\n elsif country == \"russia\"\n country = \"russian federation\"\n elsif country == \"laos\"\n country = \"lao peoples democratic republic\"\n elsif country == \"iran\"\n country = \"islamic republic of iran\"\n elsif country == \"taiwan\"\n country = \"province of china taiwan\"\n elsif country == \"north korea\"\n country = \"democratic people's republic of korea\"\n elsif country == \"south korea\"\n country = \"republic of korea\"\n elsif country == \"basque spain\"\n country = \"spain\"\n elsif country == \"macedonia\"\n country = \"the former yugoslav republic of macedonia\"\n elsif country == \"tanzania\"\n country = \"united republic of tanzania\"\n elsif country == \"vietnam\"\n country = \"viet nam\"\n elsif country == \"venezuela\"\n country = \"bolivarian republic of venezuela\"\n elsif country == \"syria\"\n country = \"syrian arab republic\"\n elsif country == \"rep.dem.congo\"\n country = \"congo\"\n elsif country == \"dagestan\"\n country = \"russian federation\"\n elsif country == \"adygea\"\n country = \"russian federation\"\n elsif country == \"karachaevo circassia\"\n country = \"russian federation\"\n elsif country == \"tartarstan\"\n country = \"russian federation\"\n #elsif country == \"ivory coast\"\n # This seems like the wrong way of doing this but not sure how else to guarentee the match\n #country = \"CÃTE D'IVOIRE\".downcase\n end\n\n country = normalize(country)\n \n @@iso_country_codes.xpath(\"//ISO_3166-1_Entry\").each do |code|\n n_country = normalize(code.xpath(\"ISO_3166-1_Country_name\")[0].content)\n\n if (country.upcase == n_country.upcase)\n return code.xpath(\"ISO_3166-1_Alpha-2_Code_element\")[0].content\n end\n end\n return \"ZZ\"\n end",
"def country\n if !block_given?\n return @j_del.java_method(:country, []).call()\n end\n raise ArgumentError, \"Invalid arguments when calling country()\"\n end",
"def get_continent(country_doc)\n my_html = Nokogiri::HTML(country_doc)\n doc = my_html.at(\"table tr td div.region1 a\")\n region = nil\n if doc != nil then\n region = doc.text.to_s\n if str_include?(region, 'Asia')\n region = 'Asia'\n elsif str_include?(region, 'middle east')\n region = 'Asia'\n end\n end\n return region\n end",
"def country_code\n if self.uk?\n UK_COUNTRY_CODE\n else\n IE_COUNTRY_CODE\n end\n end",
"def get_country_name_from_code(country_code)\n if country_code.present?\n country = ISO3166::Country[country_code]\n country.translations[I18n.locale.to_s] || country.name\n end\n end",
"def get_country_code\n Geonames::WebService.country_code @latitude, @longitude\n end",
"def country_code\n @country_code.to_s\n end",
"def country\n Faker::Address.country\n end",
"def country\n Faker::Address.country\n end",
"def identify_countries\n names = YAML.load_file( File.dirname(File.expand_path(__FILE__)) + '/lang/' + @lang + '/countries.yml' )\n names.each do |code,name|\n @svg.gsub!(\"class=\\\"land #{code}\\\"\", \"class=\\\"land #{code}\\\" country-name=\\\"#{name}\\\" country-value=\\\"#{@data[code]}\\\" onmouseover=\\\"worldMapOver(this)\\\" onmouseout=\\\"worldMapOut(this)\\\" onclick=\\\"worldMapClick(this)\\\" ondblclick=\\\"worldMapDblClick(this)\\\"\")\n end\n end",
"def country_code\n end",
"def country_code\n decode hash[\"CountryCode\"]\n end",
"def find_country\n\t\t\t@country = Category.find_by_parent_uuid_and_url_part(Category.find(:first, :conditions => [\"parent_uuid IS NULL AND url_part = ?\", \"places\"]).uuid, params[:country_id].downcase) if params[:country_id]\n\t\tend",
"def find_country\n\t\t\t@country = Category.find_by_parent_uuid_and_url_part(Category.find(:first, :conditions => [\"parent_uuid IS NULL AND url_part = ?\", \"places\"]).uuid, params[:country_id].downcase) if params[:country_id]\n\t\tend",
"def GetPlatformOfFile ( fl )\n platforms = { \"a1\" => \"AQUA-1\", \"t1\" => \"TERRA-1\", \"npp\" => \"NPP\"}\n \n x = File.basename(fl).split(\".\").first\n puts x\n return platforms[x] if ( platforms[x])\n return \"unknown\"\nend",
"def country_to_language(country_code)\n\n # sources:\n # http://en.wikipedia.org/wiki/List_of_Internet_top-level_domains\n # http://www.w3.org/WAI/ER/IG/ert/iso639.htm\n # http://msdn.microsoft.com/en-us/library/ms693062%28v=vs.85%29.aspx\n\n # country_code => language_code\n mappings = {\n # English\n :au => :en,\n :ca => :en,\n :eu => :en,\n :ie => :en,\n :nz => :en,\n :sg => :en,\n :uk => :en,\n :us => :en,\n\n # French\n :cd => :fr,\n :cg => :fr,\n :cm => :fr,\n :fr => :fr,\n :mg => :fr,\n\n # German\n :at => :de,\n :ch => :de,\n :de => :de,\n :li => :de,\n :lu => :de,\n\n # Portuguese\n :ao => :pt,\n :br => :pt,\n :mz => :pt,\n :pt => :pt,\n\n # Spanish\n :ar => :es,\n :cl => :es,\n :co => :es,\n :cu => :es,\n :es => :es,\n :mx => :es,\n\n # All other languages\n :bg => :bg,\n :by => :be,\n :cn => :zh,\n :cz => :cs,\n :dk => :da,\n :ee => :et,\n :fi => :fi,\n :gr => :el,\n :hr => :hr,\n :hu => :hu,\n :il => :he,\n :in => :hi,\n :is => :is,\n :it => :it,\n :jp => :ja,\n :kr => :ko,\n :lt => :lt,\n :lv => :lv,\n :mn => :mn,\n :nl => :nl,\n :no => :no,\n :pl => :pl,\n :ro => :ro,\n :rs => :sr,\n :ru => :ru,\n :se => :sv,\n :si => :sl,\n :sk => :sk,\n :th => :th,\n :tr => :tr,\n :ua => :uk,\n :vn => :vi,\n }\n\n if mappings.has_key?(country_code.to_sym)\n mappings[country_code.to_sym].to_s\n else\n # fall back for all other missing mappings\n I18n.default_locale.to_s\n end\n\n end",
"def get_header\n\theader = nil\n\tFile.open(\"./data/header.tex\",\"r\") do |f|\n\t\theader = f.readlines\n\tend\n\treturn header\n\t#パッケージの設定もここで入れれるといいんだが\nend",
"def get_user_country (cntry)\n\t\tuser_countries.each { |u|\n\t\t\tif u.id = cntry.id\n\t\t\t\treturn u\n\t\t\tend\n\t\t}\n\t\treturn nil\n\tend",
"def get_movie_country( the_country_num )\n @countryInfos = CountryInfo.all\n @countryInfos.each{ |country_info|\n if country_info.country_id === the_country_num\n country_info.country_name\n end\n }\n end",
"def get_country(code, options = {})\n root = get_root\n object_from_response(GogoKit::Country,\n GogoKit::CountryRepresenter,\n :get,\n \"#{root.links['self'].href}/countries/#{code}\",\n options)\n end",
"def state\n country = ISO3166::Country[country_residence]\n if country.try(:subdivisions?)\n country.subdivisions[state_code].try(:[], \"name\")\n else\n state_code\n end\n end"
] |
[
"0.66511816",
"0.640445",
"0.63179964",
"0.62392914",
"0.61957055",
"0.6162235",
"0.6160568",
"0.6121128",
"0.61086684",
"0.6094934",
"0.6092756",
"0.6082983",
"0.606678",
"0.60591793",
"0.6046856",
"0.6032826",
"0.60316855",
"0.6017057",
"0.60140425",
"0.6007601",
"0.5961274",
"0.5946877",
"0.5946877",
"0.5946877",
"0.59324676",
"0.5902395",
"0.59003526",
"0.5888788",
"0.5883896",
"0.5876434",
"0.5866042",
"0.58519757",
"0.58519757",
"0.58519757",
"0.57878596",
"0.5784693",
"0.5764609",
"0.57428443",
"0.57301736",
"0.5727833",
"0.5726912",
"0.56962734",
"0.56499004",
"0.5645557",
"0.5641723",
"0.5641627",
"0.5641627",
"0.5641627",
"0.5641627",
"0.5641627",
"0.5641627",
"0.5641627",
"0.5641627",
"0.56402254",
"0.5629952",
"0.5624699",
"0.5599742",
"0.55752975",
"0.5565538",
"0.55159014",
"0.5511591",
"0.5498951",
"0.5487361",
"0.5486198",
"0.5475728",
"0.5464021",
"0.54597545",
"0.54597545",
"0.54555845",
"0.5452538",
"0.54382074",
"0.54375035",
"0.54307157",
"0.54299235",
"0.54299235",
"0.5423516",
"0.5411285",
"0.5410897",
"0.53765064",
"0.53753304",
"0.53724647",
"0.5367044",
"0.535956",
"0.53497064",
"0.5348916",
"0.53470725",
"0.53132343",
"0.53132343",
"0.5307633",
"0.52931035",
"0.5288757",
"0.5275456",
"0.5275456",
"0.5268382",
"0.5264565",
"0.5261494",
"0.52428514",
"0.52406025",
"0.52245533",
"0.5196389"
] |
0.5985217
|
20
|
Backup of websites is often not considered until
|
def generate_rdf_abstract(b)
k = setup_abst_info(to_marc)
b.dcterms(:abstract,k.join(' ')) unless k.blank?
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def before_backup\n end",
"def system_backup\n\n\n end",
"def backups_to_keep\n @backups_to_keep ||= 2\n end",
"def perform_backup\n \n add_memories_to_dropbox! if has_dropbox?\n\n # Clone the repo incase something is writing to it while we are backing up\n run \"cd #{@home} && git clone --bare #{@repo} #{@repo}.mirror\"\n output=run \"backup perform --trigger=daily_backup --log-path #{@dirs[:logs ]}\"\n run \"cd #{@home} && rm -fr #{@repo}.mirror\"\n \n get_timestamp(output)\n end",
"def backuphosts(session,hosts)\n\trandom = sprintf(\"%.5d\",rand(100000))\n\tprint_status(\"Making Backup of the hosts file.\")\n\tsession.sys.process.execute(\"cmd /c copy #{hosts} #{hosts}#{random}.back\",nil, {'Hidden' => true})\n\tprint_status(\"Backup loacated in #{hosts}#{random}.back\")\nend",
"def backup_and_download\n @config.each do |config|\n connect_to_host(config[:host],config[:port],config[:user],config[:password])\n backup_config(config[:name],config[:format])\n download_backup(config[:host],config[:port],config[:user],config[:password],config[:name],config[:path],config[:format])\n end\n return true\n end",
"def createBackup\n fetch(\"#{@backupUrl}\", 3000)\n $LOG.info(\"#{@name} : Backupfile created\") \n sleep 120\n end",
"def backup?\n @apps.length > 100 || seconds_since_last_backup > 30*60\n end",
"def backup\n self.keep_backup && !File.exists?( backup_path ) && FileUtils.cp( self.resource.path, backup_path )\n end",
"def backup\n if Setting.getValue('backup') && Setting.getValue('backup_location').present?\n File.open(\"#{Setting.getValue('backup_location')}/taxonomy/#{self.seo_url}.json\", 'w+') do |fh|\n fh.write self.to_json\n end\n end\n end",
"def initBackup \n today = Time.now.wday\n #Do the backup either as planned or in testmode\n if ( \n (@weekdays.include?(today) && TESTMODE === false) || \n (TESTMODE === true && TESTSITE.nil?) || \n (TESTMODE === true && TESTSITE == @name)\n )\n $LOG.info(\"#{@name} : Backup initiated\") \n self.createBackup unless @backupUrl.nil?\n self.ftpDownload\n self.cleanUp\n $LOG.info(\"#{@name} : Backup completed\") \n end\n end",
"def backup?\n @backup || false\n end",
"def backup_databases\n cloud_databases - ['redis']\n end",
"def backup_subdomains\n if File.size?(SUBDOMAINS_FILE_CURRENT) && !DRY_RUN\n File.exist?(SUBDOMAINS_FILE_OLD) && File.delete(SUBDOMAINS_FILE_OLD)\n File.rename(SUBDOMAINS_FILE_CURRENT, SUBDOMAINS_FILE_OLD)\n end\n end",
"def backup \n begin\n check_if_db_exists\n is_allowed = @conn.exec(\"select datallowconn from pg_catalog.pg_database where datname='#{@options[:database]}'\")[0]['datallowconn']\n if is_allowed == 'f'\n # unquiece temporarily\n set_dataallowcon_to true\n end\n\n # Check to see if the directory for backups exists and if not, create it with parents\n unless File.exist?(@options[:bkdir])\n FileUtils.mkdir_p @options[:bkdir]\n end\n filename = \"postgresbk_#{@options[:database]}_#{Time.new.strftime(\"%m%d%y%H%M%S\")}.dump\"\n\n # The below system call assumes you have passwordless access as the user passed into the executable tool\n # either due to ~/.pgpass or pg_hba.conf has your user as a 'trust' auth method\n `pg_dump -U #{@options[:user]} #{@options[:database]} -F c -f #{@options[:bkdir]}/#{filename}`\n\n rescue Exception => e\n raise e\n ensure\n if is_allowed == 'f'\n # re quiesce \n set_dataallowcon_to false\n end\n end\n end",
"def save_backup_on_dup\n if self.duplicated_from && self.duplicated_from.restorable? && self.keep_backup\n FileUtils.mkdir_p( File.dirname( self.backup_path ))\n FileUtils.cp( self.duplicated_from.backup_path, self.backup_path )\n end\n end",
"def download\n @config.each do |config|\n download_backup(config[:host],config[:port],config[:user],config[:password],config[:name],config[:path],config[:format])\n end\n return true\n end",
"def wp_backup_configs_check(site=@site, verbose=true)\n found = []\n test_urls = []\n dirs = [ '', '/wp-content', '/wp-content/includes', '/backup', '/backups' ]\n juicy = [ '/wp-config.php', '/wp-config.php~', '/#wp-config.php#', '/wp-config.php.save', '/wp-config.php.swp', '/wp-config.php.swo', '/wp-config.php_bak', '/wp-config.bak', '/wp-config.php.bak', '/wp-config.save', '/wp-config.old', '/wp-config.php.old', '/wp-config.php.orig', '/wp-config.orig', '/wp-config.php.original', '/wp-config.original', '/wp-config.txt', '/wp-config.txt.tar.gz', '/wp-config.txt.tgz', '/wp-config.php.tar.gz', '/wp-config.php.tgz', '/wp.sql', '/db.sql', '/database.sql', '/backup.sql', '/wp_users.sql' ]\n dirs.each do |d|\n juicy.each { |j| test_urls << site.sub(/\\/$/, '') + d + j }\n end\n $config['HTTP']['PROGRESS'] = true # Enable progressbar\n mresponses = @http.multi_get(test_urls) # Curl Multi Mode Makes the Checks Faster\n $config['HTTP']['PROGRESS'] = false # Disable progressbar\n test_urls.each do |url| # Check results...\n if mresponses[url].response_code == 200\n found << url # Found One!\n end\n end\n puts\n if found.uniq.size > 0\n if verbose\n print_good(\"Found Possible Config Backups!\")\n found.each do |url|\n print_line(\" #{url}\")\n end\n end\n return found\n end\n print_error(\"No Backups Found!\")\n return nil\n end",
"def local_backup_path\n local_path\n end",
"def base_path\n Settings.form526_backup.url\n end",
"def backup(frequency,dir,t,condition)\n frequency.each do |vm|\n break if (Time.now.hour >= 5) && (Time.now.hour <= 20)\n mkdir = system(\"mkdir #{BACKUP_DIR}#{dir}#{vm} > /dev/null 2>&1\")\n %x[/bin/rm #{BACKUP_DIR}#{dir}#{vm}/*.log] if (File.exist?(\"#{BACKUP_DIR}#{dir}#{vm}/#{frequency.last}-#{t.month}-#{t.year}.log\"))#{condition}\n next if File.exist?(\"#{BACKUP_DIR}#{dir}#{vm}/#{vm}-#{t.month}-#{t.year}.log\")\n @logger = Logger.new(\"#{BACKUP_DIR}#{dir}#{vm}/#{vm}-#{t.month}-#{t.year}.log\", LOG_AGE)\n @logger.info(\"Started running\")\n case true\n when DOE_POOL.include?(vm)\n server = ''\n pass = \"\"\n when DOMAIN_POOL.include?(vm)\n server = ''\n pass = \"\"\n when SAMBP_XEN.include?(vm)\n server = ''\n pass = \"\"\n when SUNFIRE_XEN.include?(vm)\n server = ''\n pass = \"\"\n end\n result = []\n run_time = Benchmark.realtime do\n begin\n @logger.info(\"Suspend start\")\n result << system(\"xe vm-suspend vm=#{vm} -s #{server} -u root -pw #{pass} >> #{BACKUP_DIR}#{dir}#{vm}/#{vm}-#{t.month}-#{t.year}.log 2>&1\") \n @logger.info(\"Backup start\")\n result << system(\"xe vm-export vm=#{vm} filename=#{BACKUP_DIR}#{dir}#{vm}/#{vm}-$(date +%d-%m-%Y).backup -s #{server} -u root -pw #{pass} >> #{BACKUP_DIR}#{dir}#{vm}/#{vm}-#{t.month}-#{t.year}.log 2>&1\")\n @logger.info(\"Resume start\")\n result << system(\"xe vm-resume vm=#{vm} -s #{server} -u root -pw #{pass} >> #{BACKUP_DIR}#{dir}#{vm}/#{vm}-#{t.month}-#{t.year}.log 2>&1\")\n end\n end\n @logger.info(\"Removing old backup\")\n %x[rm #{BACKUP_DIR}#{dir}#{vm}/`ls -t1r #{BACKUP_DIR}#{dir}#{vm} | head -n 1`] if (result[1] == true) && (mkdir != true)\n @logger.info(\"Finished running - Backup run time: #{run_time.to_s[0, 5]}\")\n send_email_with_log(vm,t,dir) if result.include?(false) \n end\nend",
"def backup_data_sets\n EternosBackup::SiteData.site_data_sets(backup_site)\n end",
"def remote_backup_path\n remote_path\n end",
"def backup_file\n \"#{@file}.bak\"\n end",
"def backup_dir\n @backup_dir ||= create_backup_dir\n end",
"def storage_block_google_backup\n return @storage_block_google_backup\n end",
"def backup_exist?\n abs_path = File.join(__dir__, @cfg[:backup])\n if File.directory?(abs_path) && Dir.entries(abs_path).size > 200\n true\n end\n false\n end",
"def backup?\n @backup.nil? ? false : @backup\n end",
"def last_backup_at\n @last_backup_at ||= Time.now\n end",
"def make_mysql_backup\n if @all_databases\n options = {\n :name => \"--all-databases\",\n :dump_options => \"\",\n :append_name => \"\"\n }\n file_name = mysqldump(options)\n compress_file(file_name)\n end\n if @databases && !@databases.empty?\n @databases.each do |db|\n options = {\n :name => db[:name].to_s,\n :dump_options => db[:dump_options].to_s,\n :append_name => db[:append_name].to_s\n }\n file_name = mysqldump(options)\n compress_file(file_name)\n end\n end\nend",
"def backup_database\n #todo handle db prefix\n #todo proper error handling\n\n dbuser = @attributes[:dbuser]\n dbhost = @attributes[:dbhost]\n dbpass = @attributes[:dbpass]\n dbname = @attributes[:dbname]\n\n # see https://docs.moodle.org/20/en/Site_backup\n\n cmd = %Q{mysqldump -u #{dbuser} -h'#{dbhost}' -p'#{dbpass}' -C -Q -e --create-options '#{dbname}' | gzip -9 > '#{mk_backup_filename('database')}'}\n system cmd\n\n nil\n end",
"def purge_old_backups(base)\n count = fetch(:sync_backups, 5).to_i\n backup_files = capture(\"ls -xt #{shared_path}/sync/#{base}*\").split.reverse\n\n if count >= backup_files.length\n logger.info \"no old backups to clean up\"\n else\n logger.info \"keeping #{count} of #{backup_files.length} sync backups\"\n delete_backups = (backup_files - backup_files.last(count)).join(\" \")\n execute \"rm -rf #{delete_backups}\"\n end\n end",
"def backup\n # solve override problem\n if backup_exist? && !@opt[:bkp_args][:quiet]\n while true\n print \"Already have backup in #{@cfg[:backup]},override?(y/n)\"\n opt = gets\n case opt\n when /^y/i\n break\n when /^n/i\n return\n else\n next\n end\n end\n end\n \n # do backup\n FileUtils.mkdir_p @cfg[:backup] unless File.directory? @cfg[:backup]\n CommonUtils.copy_files @cfg[:local_files], File.join(__dir__, @cfg[:backup]) do |src, dest|\n @logger.debug \"Copying #{src} to #{dest}\"\n puts \"Backup: #{File.basename src}\" unless @opt[:bkp_args][:quiet]\n end\n @logger.debug('Backup completed')\n puts \"Backup completed, saved in: #{@cfg[:backup]}\" unless @opt[:bkp_args][:quiet]\n end",
"def backup \n raise NotImplementedError.new\n end",
"def backup(id)\n server = @connection.servers.get(id)\n ssh(server,'~/backup.sh')\n server.scp_download('backup/current.tar.gz','backup.tar.gz')\n end",
"def backup2Drive(src,conf)\n dest = conf[:backupDrive]\n dest = dest + \"/\" unless dest [-1] =~ /[\\/\\\\]/\n dest = dest + src\n puts src\n puts dest\n FileUtils.mkdir_p(File.dirname(dest))\n FileUtils.cp(src, dest)\n puts aktTime()+\" archive copied\"\n cleanUp(conf) if conf[:generations]\n \nend",
"def backup_files host, config\n files = expand_files host, config\n files = expand_files \"default\", config if files.empty? # Undefined hosts get default\n return files\nend",
"def write_backup(filename = nil)\n Doing.logger.benchmark(:_write_backup, :start)\n filename ||= Doing.setting('doing_file')\n\n unless File.exist?(filename)\n Doing.logger.debug('Backup:', \"original file doesn't exist (#{filename})\")\n return\n end\n\n backup_file = File.join(backup_dir, \"#{timestamp_filename}___#{File.basename(filename)}\")\n # compressed = Zlib::Deflate.deflate(content)\n # Zlib::GzipWriter.open(backup_file + '.gz') do |gz|\n # gz.write(IO.read(filename))\n # end\n\n FileUtils.cp(filename, backup_file)\n\n prune_backups(filename, Doing.setting('history_size').to_i)\n clear_undone(filename)\n Doing.logger.benchmark(:_write_backup, :finish)\n end",
"def clean_download_dir\n dir('~/Downloads/*').each do |path|\n trash path if File.mtime(path) < TWO_WEEKS_AGO\n end\n end",
"def backup\n #EternosBackup::BackupJobPublisher.add_source(self)\n end",
"def get_backup\n safe_run \"scp #{user}@#{host}:#{remote_path} #{local_path}\"\n local_path\n end",
"def run_reboot_checks\n # one simple check we can do is the backup. Backup can fail if anything is amiss\n @servers.each do |server|\n run_script(\"do_backup\", server)\n end\n end",
"def do_backed_up\n self.update_attributes(:needs_initial_scan => false)\n update_last_backup_times\n end",
"def dump_web_pages_of_univ(filename,content)\n File.open(\"./page_data/#{filename}\", \"w+\" ) do |f|\n f.puts(content)\n end\n\n # keep a checklist of downloaded/missing one\n \n\nend",
"def before_copy_backup\n return :success\n end",
"def item_backup_url(id)\n \"#{@baseurl}/view.aspx?cabinet=published_meetings&fileid=#{id}\"\n end",
"def find_files_on_backup conf\n file_matcher = generate_intended_filename_regex conf\n unless BACKUP_SERVERS[conf['backup_hostname']]\n bs = BackupServer.new(conf['backup_hostname'], \n conf['backup_username'], \n conf['backup_destination'])\n BACKUP_SERVERS[conf['backup_hostname']] = bs\n end\n bs = BACKUP_SERVERS[conf['backup_hostname']]\n files = bs.all_files.select {|file| /#{ file_matcher }/ =~ file[:name] }\n return files.reverse()[0,20]\nend",
"def tmpbkup(action=:create)\n bkup=@bkup\n begin\n if action == :create\n # Thx SO; https://stackoverflow.com/questions/88311/how-to-generate-a-random-string-in-ruby\n marker = (0...8).map { ('a'..'z').to_a[rand(26)] }.join\n\n Pem::Logger.logit(\"Creating backup of #{@location} to #{@location}#{marker}\")\n FileUtils.mv(@location,\"#{@location}#{marker}\")\n return \"#{@location}#{marker}\"\n elsif action == :restore\n Pem::Logger.logit(\"Backup cannot be nil!\", :fatal) if bkup.nil?\n raise('Backup cannot be nil!') if bkup.nil?\n\n Pem::Logger.logit(\"Restoring backup of #{@location} from #{bkup}\")\n FileUtils.rm_rf(@location)\n FileUtils.mv(bkup,@location)\n return nil\n elsif action == :purge\n Pem::Logger.logit(\"Backup cannot be nil!\", :fatal) if bkup.nil?\n raise('Backup cannot be nil!') if bkup.nil?\n\n Pem::Logger.logit(\"Purging backup of #{@location} from #{bkup}\")\n FileUtils.rm_rf(bkup)\n return nil\n end\n rescue StandardError => err\n Pem::Logger.logit(err, :fatal)\n raise(err)\n end\n end",
"def backup(job)\n write_thread_var :job, job\n write_thread_var :source, job.backup_source\n\n worker = BackupWorker::WorkerFactory.create_worker(workitem.source_name, job)\n\n unless worker.authenticate\n auth_failed worker.errors.to_s\n return false\n end\n\n # We must disable ThinkingSphinx in every thread!\n turn_off_thinking_sphinx\n \n worker.run workitem.options\n\n save_error worker.errors.to_s if worker.errors.any?\n # Return backup success status\n worker.errors.empty?\n end",
"def backup\n inexistent_files = check_for_inexistent_files\n unless inexistent_files.empty?\n STDERR.puts \"Cannot backup inexistent files\"\n STDERR.puts inexistent_files.join(\" \")\n exit 1\n end\n\n FileUtils.mkdir_p @backup_folder unless File.exists? @backup_folder\n\n if @no_compress \n copy_files \n delete_uncompressed_backups\n else\n compress_files_and_copy\n delete_compressed_backups\n end\n\n end",
"def for_backups?\n hostname.start_with?('backup') || in_remote_datacenter?\n end",
"def generate_backup\n if Export.launch_export!\n current_user.update(\n last_backup_at: Time.zone.now,\n last_backup_entry_id: current_user.last_entry_id\n )\n redirect_to backup_succeeded_path\n else\n redirect_to backup_failed_path\n end\n end",
"def backup\n run_command 'pgbackups:capture', %W(--expire #{database})\n end",
"def backup_location\n @location\n end",
"def scrape_n_save(url, redis)\n scrape_page_for_zip_hrefs(url).each do |zip_url|\n save_single_zip_to_redis(zip_url, redis)\n end\nend",
"def backuppassword\n @shadow_location = \"#{@home}/etc/#{domain}\"\n @shadow = \"#{@shadow_location}/shadow\"\n @backup_account = `grep -w ^#{@email_account_without_domain} #{@shadow} > #{@shadow_location}/#{@email_account_without_domain}.mailtool`\n end",
"def delete_uncompressed_backups\n end",
"def backup!\n return false unless File.exists?(app_dest) && File.exists?(prefs_dest)\n\n puts \" application: #{app_dest.inspect}\"\n FileUtils.rm_r(app_bak, secure: true) if File.exists?(app_bak)\n # FileUtils.cp_r(app_dest, app_bak)\n # the call to `FileUtils` was not copying the application icon, so I'm using\n # a call to `system` to properly copy application directories\n system(%Q/cp -r \"#{app_dest}\" \"#{app_bak}\"/)\n\n puts \" preferences: #{prefs_dest.inspect}\"\n FileUtils.rm_r(prefs_bak, secure: true) if File.exists?(prefs_bak)\n FileUtils.cp(prefs_dest, prefs_bak)\n\n true\n end",
"def capture\n db = resolve_db(:allow_default => true)\n\n from_url = db[:url]\n from_name = db[:name]\n to_url = nil # server will assign\n to_name = \"BACKUP\"\n opts = {:expire => extract_option(\"--expire\")}\n\n backup = transfer!(from_url, from_name, to_url, to_name, opts)\n\n to_uri = URI.parse backup[\"to_url\"]\n backup_id = to_uri.path.empty? ? \"error\" : File.basename(to_uri.path, '.*')\n display \"\\n#{db[:pretty_name]} ----backup---> #{backup_id}\"\n\n backup = poll_transfer!(backup)\n\n if backup[\"error_at\"]\n message = \" ! An error occurred and your backup did not finish.\"\n message += \"\\n ! The database is not yet online. Please try again.\" if backup['log'] =~ /Name or service not known/\n message += \"\\n ! The database credentials are incorrect.\" if backup['log'] =~ /psql: FATAL:/\n abort(message)\n end\n end",
"def app_store_block_automatic_downloads\n return @app_store_block_automatic_downloads\n end",
"def get_recent_backup\n puts \"entered get_recent_backup\" if DEBUG\n filename = \"#{@config['folder']}/#{@config['filename']}_#{(Time.now - (60*60*24*14)).strftime(\"%Y-%m-%d_%H-%M\")}\"\n list = Bucket.objects(@config['bucket'], :prefix => @config['folder'])\n raise 'Could not find any backups.' if not list\n list.sort!{|a,b| b.key <=> a.key }\n raise 'Could not find a recent backup.' if not list.first\n list.first.key\n end",
"def backup_file\n \"#{options[:file]}.bak\"\n end",
"def create_and_copy_backup(backup_options = nil,backup_name = nil)\n\n end",
"def after_copy_backup\n return :success\n end",
"def backup(job)\n path = @filesystem.get_tmp_path\n s3 = @storage.parse_location(job['location'])\n db = @db.get_opts(job['db'])\n \n Mongolicious.logger.info(\"Starting job for #{db[:host]}:#{db[:port]}/#{db[:db]}\")\n\n @db.dump(db, path)\n @filesystem.compress(path) \n \n key = \"#{s3[:prefix]}_#{Time.now.strftime('%m%d%Y_%H%M%S')}.tar.bz2\"\n @storage.upload(s3[:bucket], key, path)\n \n @filesystem.cleanup(path)\n @storage.cleanup(s3[:bucket], s3[:prefix], job['versions'])\n \n Mongolicious.logger.info(\"Finishing job for #{db[:host]}:#{db[:port]}/#{db[:db]}\") \n end",
"def backup_target\n data[:backup_target]\n end",
"def backup(path_to_backup_file) \n logger.info \"Uploading backup to FTP: #{worker.user_host_and_dir}\"\n @worker.connect_and_put_file path_to_backup_file\n end",
"def get_backups_list(backup_name)\n logger.info \"Getting the list of backups from FTP: #{worker.user_host_and_dir}\"\n @worker.get_files_list backup_name\n end",
"def request_backup(db)\r\n\t\tdb.execute(\"SELECT * FROM playgroups WHERE kids>=5\")\r\n\t\tputs \"We'll need backup!!!\"\r\n\tend",
"def backup_url(site_id, backup_id, lifetime = 60)\n @conn.get(\"/api/v1/sites/#{site_id}/backups/#{backup_id}/url?lifetime=#{lifetime}\")\n end",
"def run_reboot_checks\n # one simple check we can do is the backup. Backup can fail if anything is amiss\n [s_one, s_two].each do |server|\n run_script(\"backup\", server)\n end\n end",
"def backup_retention_period\n @dbi.backup_retention_period\n end",
"def backup_retention_period\n @dbi.backup_retention_period\n end",
"def transfer\n\t\tattributes = super\n\t\tself.last_backup_date = Date.today\n\t\tset_next_backup_date\n\t\tself.save\n\t\tlog_transfer(attributes)\n\tend",
"def backup_configuration\n settings[\"backup_configuration\"]\n end",
"def write_urls_db()\n end",
"def backup!(chroot=nil)\n self.root = chroot if chroot\n return unless stores.any?{ |dir| File.exist?(dir) }\n FileUtils.mkdir_p(cache) unless File.exist?(cache)\n stores.each do |store|\n temp, $DEBUG = $DEBUG, false\n FileUtils.cp_r(store, cache) if File.exist?(store)\n $DEBUG = temp\n end\n return cache\n end",
"def sync_local\n sync_hash = {\n ['~/Library/Application\\\\ Support/Firefox', '~/Library/Application\\\\ Support/Quicksilver',\n '~/Library/Preferences' ] =>'library/',\n ['~/.boson', '~/.sake', '~/.cronrc', '~/.gemrc', '~/.gitconfig', '~/.gem/specs']=>'dotfiles/',\n }\n sync_hash.each do |src, dest|\n src.each do |e| \n cmd = \"rsync -av #{e} #{File.join('~/backup', dest)}\"\n system cmd\n end\n end\n end",
"def make_backup\n print_title('Data backup')\n\n @backup_type ||= prompt.select('What type of backup do you want?',\n 'Full (redmine root and database)' => :full,\n 'Only database' => :database,\n 'Nothing' => :nothing)\n\n logger.info(\"Backup type: #{@backup_type}\")\n\n # Dangerous option\n if @backup_type == :nothing\n if prompt.yes?('Are you sure you dont want backup?', default: false)\n logger.info('Backup option nothing was confirmed')\n return\n else\n @backup_type = nil\n return make_backup\n end\n end\n\n @backup_root ||= prompt.ask('Where to save backup:', required: true, default: DEFAULT_BACKUP_ROOT)\n @backup_root = File.expand_path(@backup_root)\n\n @backup_dir = File.join(@backup_root, Time.now.strftime('backup_%d%m%Y_%H%M%S'))\n create_dir(@backup_dir)\n\n files_to_backup = []\n Dir.chdir(root) do\n case @backup_type\n when :full\n files_to_backup = Dir.glob(File.join('**', '{*,.*}'))\n end\n end\n\n if files_to_backup.any?\n files_to_backup.delete_if do |path|\n path.start_with?(*BACKUP_EXCLUDE_FILES)\n end\n\n @backup_package = File.join(@backup_dir, 'redmine.zip')\n\n Dir.chdir(root) do\n puts\n puts 'Files backuping'\n Zip::File.open(@backup_package, Zip::File::CREATE) do |zipfile|\n progressbar = TTY::ProgressBar.new(PROGRESSBAR_FORMAT, total: files_to_backup.size, frequency: 2, clear: true)\n\n files_to_backup.each do |entry|\n zipfile.add(entry, entry)\n progressbar.advance(1)\n end\n\n progressbar.finish\n end\n end\n\n puts \"Files backed up on #{@backup_package}\"\n logger.info('Files backed up')\n end\n\n @database = Database.init(self)\n @database.make_backup(@backup_dir)\n\n puts \"Database backed up on #{@database.backup}\"\n logger.info('Database backed up')\n end",
"def backup_request(client, filename, message)\n filename = \"BACKUP_#{filename}\"\n aFile = File.open(filename, 'w+')\n if aFile\n File.write(filename, message)\n puts \"Updated: #{filename}\"\n else\n client.puts \"ERROR: Unable to open file #{filename}\"\n end\n aFile.close\n return\n end",
"def copy_files (infiles)\n @log.d(\"Backing up files...\");\n htfiles = [];\n backup_dir = @ht_backup_dir + Time.new().strftime(\"%Y%m%d\");\n infiles.each do |infile|\n ht_file = @ht_dir + infile.split('/').last;\n # Check if file exists in ht00x\n if File.exists?(ht_file) then\n # If so, back it up.\n FileUtils.mkdir_p(backup_dir);\n @log.d(\"cp #{ht_file} #{backup_dir}\");\n if @dry_run == false then\n FileUtils.cp(ht_file, backup_dir);\n end\n end\n # Overwrite with one from memberdata (copy)\n @log.d(\"cp #{infile} #{ht_file}\");\n if @dry_run == false then\n FileUtils.cp(infile, ht_file);\n end\n htfiles << ht_file;\n end\n\n return htfiles;\nend",
"def backup\n\t\tunless (@options && @options[:path] && @options[:dataset])\n\t\t\traise OptionParser::InvalidArgument, \"Missing arguments for 'backup'.\"\n\t\tend\n\t\t# Only attempt backup if the service is running\n\t\tstate = false\n\t\tself.launch(\"/usr/sbin/serveradmin status postgres\") do |output|\n\t\t\tstate = ((/RUNNING/ =~ output) != nil)\n\t\tend\n\t\torig_state = state\n\t\t$log.debug(\"@options = #{@options.inspect}\")\n\t\tarchive_dir = @options[:path]\n\t\tunless (archive_dir[0] == ?/)\n\t\t\traise OptionParser::InvalidArgument, \"Paths must be absolute.\"\n\t\tend\n\t\twhat = @options[:dataset]\n\t\tunless self.class::DATASETS.include?(what)\n\t\t\traise OptionParser::InvalidArgument, \"Unknown data set '#{@options[:dataset]}' specified.\"\n\t\tend\n\t\t# The passed :archive_dir and :what are ignored because the dump is put\n\t\t# on the live data volume\n\t\tarchive_dir = self.backupDir\n\t\tdump_file = \"#{archive_dir}/#{BACKUP_FILE}\"\n\t\tdump_file_uncompressed = \"#{archive_dir}/#{BACKUP_FILE_UNCOMPRESSED}\"\n\t\t# Create the backup directory as necessary.\n\t\tunless File.directory?(archive_dir)\n\t\t\tif File.exists?(archive_dir)\n\t\t\t\t$log.info \"Moving aside #{archive_dir}...\\n\"\n\t\t\t\tFileUtils.mv(archive_dir, archive_dir + \".applesaved\")\n\t\t\tend\n\t\t\t$log.info \"Creating backup directory: #{archive_dir}...\\n\"\n\t\t\tFileUtils.mkdir_p(archive_dir, :mode => 0700)\n\t\t\t# _postgres:_postgres has uid:gid of 216:216\n\t\t\tFile.chown(216, 216, archive_dir)\n\t\tend\n\t\t# Backup only once a day\n\t\tmod_time = File.exists?(dump_file) ? File.mtime(dump_file) : Time.at(0)\n\t\tif (Time.now - mod_time) >= (24 * 60 * 60)\n\t\t\t# Attempt to start the service if needed\n\t\t\tif (! state)\n\t\t\t\tself.launch(\"/usr/sbin/serveradmin start postgres\") do |output|\n\t\t\t\t\tstate = ((/RUNNING/ =~ output) != nil)\n\t\t\t\tend\n\t\t\tend\n\t\t\tif (! state)\n\t\t\t\t$log.info \"PostgreSQL is not running, skipping database backup\"\n\t\t\t\treturn\n\t\t\tend\n\n\t\t\t$log.info \"Creating dump file \\'#{dump_file}\\'...\"\n\t\t\tsystem(\"/usr/bin/sudo -u _postgres /usr/bin/pg_dumpall > #{dump_file_uncompressed.shellescape}\")\n\t\t\tif ($?.exitstatus != 0)\n\t\t\t\t$log.error \"...Backup failed on pg_dumpall, Status=#{$?.exitstatus}\"\n\t\t\telse\n\t\t\t\tsystem(\"/usr/bin/gzip #{dump_file_uncompressed.shellescape}\")\t\t\t\t\n\t\t\t\tif ($?.exitstatus == 0)\n\t\t\t\t\tFile.chmod(0640, dump_file)\n\t\t\t\t\tFile.chown(216, 216, dump_file)\n\t\t\t\t\t$log.info \"...Backup succeeded.\"\n\t\t\t\telse\n\t\t\t\t\t$log.error \"...Backup failed on gzip! Status=#{$?.exitstatus}\"\n\t\t\t\tend\n\t\t\tend\n\n\t\t\t# Restore original service state\n\t\t\tif (! orig_state)\n\t\t\t\t# What if a dependent service was launched while we were backing up? We\n\t\t\t\t# don't want to shut down postgres in that case.\n\t\t\t\twiki_state = false\n\t\t\t\tcalendar_state = false\n\t\t\t\taddressbook_state = false\n\t\t\t\tdevicemgr_state = false\n\t\t\t\tself.launch(\"/usr/sbin/serveradmin status wiki\") do |output|\n\t\t\t\t\twiki_state = ((/RUNNING/ =~ output) != nil)\n\t\t\t\tend\n\t\t\t\tself.launch(\"/usr/sbin/serveradmin status calendar\") do |output|\n\t\t\t\t\tcalendar_state = ((/RUNNING/ =~ output) != nil)\n\t\t\t\tend\n\t\t\t\tself.launch(\"/usr/sbin/serveradmin status addressbook\") do |output|\n\t\t\t\t\taddressbook_state = ((/RUNNING/ =~ output) != nil)\n\t\t\t\tend\n\t\t\t\tself.launch(\"/usr/sbin/serveradmin status devicemgr\") do |output|\n\t\t\t\t\tdevicemgr_state = ((/RUNNING/ =~ output) != nil)\n\t\t\t\tend\n\t\t\t\tif (! (wiki_state || calendar_state || addressbook_state || devicemgr_state))\n\t\t\t\t\tself.launch(\"/usr/sbin/serveradmin stop postgres\")\n\t\t\t\tend\n\t\t\tend\n\t\telse\n\t\t\t$log.info \"Dump file is less than 24 hours old; skipping.\"\n\t\tend\n\tend",
"def store_backup\n ret = true\n base = Util.data_path(EMMConfig[\"DATA_BACK_DIR\"])\n $files.each do |f|\n # directory of the file \n # LSMSS10, LSMSS30 , etc\n dir = File.basename(File.expand_path(\"#{f}/..\"))\n back_path = base + \"/\" + dir + \"/\" + File.basename(f)\n cmd = \"mv #{f} #{back_path}\"\n unless system(cmd)\n $stderr.puts \"Move #{cmd} did not work ... Next\" if $opts[:v]\n ret = false\n next\n end\n\n # compress the file\n cmd = EMMConfig[\"COMPRESS\"] + \" #{back_path}\"\n unless system(cmd)\n $stderr.puts \"Compress #{cmd} did not work ... Next\" if $opts[:v]\n ret = false\n next\n end\n end \n ret\nend",
"def download\n if Rails.env.production?\n redirect_to @upload.archive.expiring_url(10)\n else\n redirect_to @upload.archive.url\n end\n end",
"def create_backup(site_id, datum = nil)\n current_path = \"/api/v1/sites/#{site_id}/backup\"\n @conn.post(current_path, datum.to_json)\n end",
"def wRestoreDump()\n puts \"Back up commencing...\"\n Dir.chdir('/Users/jeydurai')\n system('start_mongorestore.bat')\n end",
"def store_page(url, contents, user, group, timestamp)\n puts \"storing #{url} of size #{contents.size} by user #{user.name}, for #{group.name} at #{timestamp}\"\n @db_mutex.synchronize do \n Uploader.upload(:filename => File.dirname(URI.parse(url).path), :user => user,\n :source => url, :io => contents, :groups => [group])\n end\n end",
"def backup\n return false if !@file || !backup_file\n FileUtils.cp @file, backup_file if File.file? @file\n true\n end",
"def backup\n ModelHelper::backup self\n end",
"def get_backups(site_id, datum = nil)\n current_path = \"/api/v1/sites/#{site_id}/backups\"\n pb = SFRest::Pathbuilder.new\n @conn.get URI.parse(pb.build_url_query(current_path, datum)).to_s\n end",
"def backup_file(uploaded_file)\n uploaded_file(uploaded_file.to_json) do |file|\n file.data[\"storage\"] = backup_storage.to_s\n end\n end",
"def wDumpAllDatabase()\n puts \"Back up commencing...\"\n Dir.chdir('/Users/jeydurai')\n system('start_mongodump.bat')\n end",
"def download_backup(host,port,user,password,name,path,format)\n connect_to_host(host,port,user,password,true)\n if format == 'binary'\n local_file = path+name+\".backup\"\n remote_file = name+\".backup\"\n elsif format== 'script'\n local_file = path+name+\".rsc\"\n remote_file = name+\".rsc\"\n end\n download_file(remote_file,local_file)\n @ssh_connect.close(@ssh_connect)\n end",
"def download\n if platinum_user_and_above?\n urls=SiteUrl.where(\"site is not null\")\n workbook = RubyXL::Workbook.new\n worksheet = workbook.worksheets[0]\n worksheet.sheet_name = 'urls'\n header = [\"Site\",\"Url\",\"Last Update\"]\n index = 0\n worksheet_write_row(worksheet,index,header)\n urls.each do |url|\n next if url.site.nil?\n next if url.site.empty?\n index += 1\n my_row = [url.site, url.url, url.updated_at]\n worksheet_write_row(worksheet,index, my_row)\n end\n file = \"Discovered_Urls_\" + Time.now.strftime('%m%d%Y') + \".xlsx\"\n send_data workbook.stream.string, filename: file, disposition: 'attachment'\n else\n redirect_back :fallback_location => root_path, :alert => \"Access denied.\"\n end\n end",
"def backup_retention_period\n data[:backup_retention_period]\n end",
"def backup_retention_period\n data[:backup_retention_period]\n end",
"def keep_backup(nb_to_keep,down_date, up_date)\n range = down_date..up_date\n nb_kept = 0\n self.reverse_each do |bck|\n if range === bck.date\n if nb_kept < nb_to_keep\n if bck.to_keep != true\n puts \"#{bck.filepath} will be kept!\"\n bck.to_keep = true\n nb_kept += 1\n end\n end\n end\n end\n return nb_kept\n end",
"def storage_block_google_backup=(value)\n @storage_block_google_backup = value\n end",
"def perform\n tmp_mongo_dir = \"mongodump-#{Time.now.strftime(\"%Y%m%d%H%M%S\")}\"\n tmp_dump_dir = File.join(tmp_path, tmp_mongo_dir)\n\n case self.backup_method.to_sym\n when :mongodump\n #this is the default options \n # PROS:\n # * non-locking\n # * much smaller archive sizes\n # * can specifically target different databases or collections to dump\n # * de-fragements the datastore\n # * don't need to run under sudo\n # * simple logic\n # CONS:\n # * a bit longer to restore as you have to do an import\n # * does not include indexes or other meta data\n log system_messages[:mongo_dump]\n exit 1 unless run \"#{mongodump} #{mongodump_options} #{collections_to_include} -o #{tmp_dump_dir} #{additional_options} > /dev/null 2>&1\"\n when :disk_copy\n #this is a bit more complicated AND potentially a lot riskier: \n # PROS:\n # * byte level copy, so it includes all the indexes, meta data, etc\n # * fast recovery; you just copy the files into place and startup mongo\n # CONS:\n # * locks the database, so ONLY use against a slave instance\n # * copies everything; cannot specify a collection or a database\n # * will probably need to run under sudo as the mongodb db_path file is probably under a different owner. \n # If you do run under sudo, you will probably need to run rake RAILS_ENV=... if you aren't already\n # * the logic is a bit brittle... \n log system_messages[:mongo_copy]\n\n cmd = \"#{mongo} #{mongo_disk_copy_options} --quiet --eval 'printjson(db.isMaster());' admin\"\n output = JSON.parse(run(cmd, :exit_on_failure => true))\n if output['ismaster']\n puts \"You cannot run in disk_copy mode against a master instance. This mode will lock the database. Please use :mongodump instead.\"\n exit 1\n end\n \n begin\n cmd = \"#{mongo} #{mongo_disk_copy_options} --quiet --eval 'db.runCommand({fsync : 1, lock : 1}); printjson(db.runCommand({getCmdLineOpts:1}));' admin\"\n output = JSON.parse(run(cmd, :exit_on_failure => true))\n\n #lets go find the dbpath. it is either going to be in the argv just returned OR we are going to have to parse through the mongo config file\n cmd = \"mongo --quiet --eval 'printjson(db.runCommand({getCmdLineOpts:1}));' admin\"\n output = JSON.parse(run(cmd, :exit_on_failure => true))\n #see if --dbpath was passed in\n db_path = output['argv'][output['argv'].index('--dbpath') + 1] if output['argv'].index('--dbpath') \n #see if --config is passed in, and if so, lets parse it\n db_path ||= $1 if output['argv'].index('--config') && File.read(output['argv'][output['argv'].index('--config') + 1]) =~ /dbpath\\s*=\\s*([^\\s]*)/ \n db_path ||= \"/data/db/\" #mongo's default path\n run \"cp -rp #{db_path} #{tmp_dump_dir}\" \n ensure\n #attempting to unlock\n cmd = \"#{mongo} #{mongo_disk_copy_options} --quiet --eval 'printjson(db.currentOp());' admin\"\n output = JSON.parse(run(cmd, :exit_on_failure => true))\n (output['fsyncLock'] || 1).to_i.times do\n run \"#{mongo} #{mongo_disk_copy_options} --quiet --eval 'db.$cmd.sys.unlock.findOne();' admin\"\n end\n end\n else\n puts \"you did not enter a valid backup_method option. Your choices are: #{BACKUP_METHOD_OPTIONS.join(', ')}\"\n exit 1\n end \n \n log system_messages[:compressing]\n run \"tar -cz -C #{tmp_path} -f #{File.join(tmp_path, compressed_file)} #{tmp_mongo_dir}\"\n end",
"def before_restore\n stop_postgres\n # Remove symlink to oltp\n FileUtils.rm_r '/data/db/oltp'\n create_directory\n change_ownership(\"barman\")\n change_permissions($seven_five_five)\n edit_backup_info\nend",
"def file_content file_name=HOSTS_FILE\n \n begin\n\tfilename = File.realpath(file_name)\n\t\tbkup = filename + \".backup\"\n\t\t\tbackup_files = Dir.glob(bkup + \"*\").sort_by do |f|\n\t\t\t\tf.match(/\\d+$/)\n\t\t\t\t$&.nil? ? 0 : $&.to_i\n\t\t\tend\n\t\tbackup_files.reverse.each do |fname|\n\t\t\tif m = fname.match(/\\.backup\\.(\\d+)$/)\n\t\t\t\tFile.rename(fname, \"%s.%d\" % [bkup, m[1].to_i + 1])\n\t\t\telsif fname == bkup\n\t\t\t\tFile.rename(bkup, bkup + \".1\")\n\t\t\tend\n\t\n\t\tend\n rescue Exception => ex\n\tputs \"OOPS, the backup wasn't destroyed the last time you ran this script\"\n end \n #read the file\n content = \"\"\n file = File.open(file_name, \"r\")\n while (line = file.gets)\n content += \"#{line}\"\n end\n file.close \n content\nend"
] |
[
"0.6760374",
"0.65854764",
"0.6568706",
"0.65109974",
"0.63714516",
"0.63710374",
"0.6369073",
"0.63092065",
"0.6279789",
"0.62043643",
"0.61842984",
"0.6123452",
"0.6004151",
"0.59951764",
"0.59724164",
"0.5958574",
"0.5903095",
"0.5886609",
"0.58676755",
"0.58336115",
"0.58302975",
"0.5819685",
"0.58136374",
"0.58075",
"0.5805343",
"0.5781987",
"0.5754875",
"0.57310194",
"0.5730218",
"0.57233745",
"0.57123744",
"0.5679761",
"0.5654331",
"0.56537044",
"0.5652027",
"0.56454563",
"0.5642588",
"0.5639151",
"0.5631705",
"0.5629716",
"0.5628476",
"0.562201",
"0.5604019",
"0.56018496",
"0.5592511",
"0.5586307",
"0.55514055",
"0.553892",
"0.5533913",
"0.55289656",
"0.55075616",
"0.5504436",
"0.5497506",
"0.5480459",
"0.5478007",
"0.5472501",
"0.54722345",
"0.5462971",
"0.54470134",
"0.54199046",
"0.541941",
"0.54021126",
"0.5400243",
"0.53942597",
"0.5384542",
"0.53815436",
"0.53809714",
"0.5377624",
"0.5375103",
"0.5368085",
"0.5366558",
"0.53562057",
"0.53562057",
"0.5355349",
"0.5347509",
"0.534711",
"0.5334819",
"0.53348064",
"0.53309387",
"0.5329584",
"0.53237474",
"0.53196883",
"0.5319164",
"0.5315726",
"0.5311771",
"0.5304282",
"0.52902377",
"0.5272718",
"0.5268997",
"0.5266818",
"0.5252642",
"0.5252409",
"0.52378803",
"0.52337664",
"0.52238446",
"0.52238446",
"0.52236587",
"0.52209646",
"0.5218523",
"0.52177167",
"0.5200659"
] |
0.0
|
-1
|
if eresource put catalog link in coverage else put in url field.
|
def generate_rdf_catlink(b,ty)
ul = "http://catalog.library.cornell.edu/catalog/#{id}"
# if no elect access data, 'description' field.
b.dc(:description,ul)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def catalog_generator(bib)\n QuickSearch::Engine::WORLD_CAT_DISCOVERY_API_ARTICLE_CONFIG['url_link'] +\n bib.oclc_number.to_s\n end",
"def ajax_catalog_link_and_source\n instance_id = params['instanceId']\n url = ENV['OKAPI_URL']\n tenant = ENV['OKAPI_TENANT']\n # Get instance HRID (e.g., bibid) for the record\n response = CUL::FOLIO::Edge.instance_record(url, tenant, folio_token, instance_id)\n link = nil\n source = nil\n if response[:code] < 300\n source = response[:instance]['source']\n # Try to identify ILL items and set source manually -- it's 'FOLIO' in the actual record.\n source = 'ill' if ill_item?(response[:instance])\n\n # Ignore Borrow Direct records for the link -- they have an HRID that looks like a legit bibid, but\n # it's something else BD-related. We can't link to those. But now, most sources are either MARC or\n # FOLIO. A FOLIO source indicates that this was a locally-created record -- e.g., for a temporary record\n # for a BD/ReShare item. Most of the others appear to be MARC-source. This is probably not entirely accurate,\n # but we can filter out the FOLIO records and probably get things right most of the time.\n link = \"https://newcatalog.library.cornell.edu/catalog/#{response[:instance]['hrid']}\" if source == 'MARC'\n end\n render json: { link: link, source: source }\n end",
"def supplier_detail_link\n if supplier.product_base_url.blank? or self.supplier_product_code.blank?\n return nil\n else\n return \"#{supplier.product_base_url}#{self.supplier_product_code}\"\n end\n end",
"def coverage_path; end",
"def url\n if @resource.element\n @resource.uri.sub /\\{.*\\}/, @testcase.id.to_s\n else\n @resource.uri\n end\n end",
"def exception_links(exception_report)\n super(exception_report) + [[\"Report to Lighthouse\", \"/lighthouse/report/#{exception_report.id}.html\"]]\n end",
"def href; end",
"def get_link(region)\r\n base_addr = \"http://www.1st-for-french-property.co.uk/property/region/\"\r\n link = \"\"\r\n\r\n if region == 'Alsace'\r\n link = \"http://www.1st-for-french-property.co.uk/property/main-1.php?var=state&tt=France&ss=Alsace&var1=mls\"\r\n elsif region == \"Lorraine\"\r\n link = \"http://www.1st-for-french-property.co.uk/property/main-1.php?var=state&tt=France&ss=Lorraine&var1=mls\"\r\n else\r\n link = File.join(base_addr, region)\r\n end\r\n enc_link = URI.escape(link)\r\n\r\n @log.debug \"The region link is: #{enc_link}\"\r\n return enc_link\r\n end",
"def ar_resource_url resource= @resource\n meth= \"#{ardata.resource_method(@parent_resource, '')}_url\"\n \n if @parent_resource\n send meth, @parent_resource, resource\n else\n send meth, resource\n end\n end",
"def external_link_inventory # make this an object attribute for every page object, along with base url, and other helpful state info\n []\n end",
"def custom_link\n if self.permalink.blank?\n self.company_name\n else\n self.permalink\n end\n end",
"def frontcover_url\n if @collateral_detail\n @collateral_detail.frontcover_url\n end\n end",
"def url(source)\n h.purchase_url purchase.user.handle,purchase.handle,:src => source\n end",
"def resource_url\n return super unless resource.is_a?(Decidim::Component)\n\n @resource_url ||= main_component_url(resource)\n end",
"def look_up_link(result)\n case name\n when \"IGN\" then return result.attributes[\"href\"].value\n when \"GameSpot\" then return \"http://\" + base_url + result.attributes[\"href\"].value\n when \"GiantBomb\" then return \"http://\" + base_url + result.attributes[\"href\"].value\n end\n end",
"def exemption_url\n caz_data[:exemption_url]\n end",
"def resource_url; nil end",
"def uri\n @uri_parameters = {:s => @company}\n super() \n end",
"def add_link\n @bib.link.each do |l|\n case l.type&.downcase\n when \"doi\" then @item.doi = l.content\n when \"file\" then @item.file2 = l.content\n when \"src\" then @item.url = l.content\n end\n end\n end",
"def resource_link=(value)\n @resource_link = value\n end",
"def fetch\n if self.rdf_subject.to_s.include?('loc.gov') then\n self.rdf_subject.to_s.gsub!('http', 'https')\n end\n\n super\n\n if self.rdf_subject.to_s.include?('loc.gov') then\n self.rdf_subject.to_s.gsub!('https', 'http')\n end\n end",
"def fetch\n if self.rdf_subject.to_s.include?('loc.gov') then\n self.rdf_subject.to_s.gsub!('http', 'https')\n end\n\n super\n\n if self.rdf_subject.to_s.include?('loc.gov') then\n self.rdf_subject.to_s.gsub!('https', 'http')\n end\n end",
"def create_link_to_reports(agency, report_name)\n ENV['RAILS_HOST'] + \"/catalog?utf8=%E2%9C%93&locale=en&agency=#{URI::encode(agency)}\" +\n \"&required_report_name=#{URI::encode(report_name)}\" +\n '&sort=date_published_ssi+desc&search_field=advanced'\n end",
"def link() url; end",
"def link() url; end",
"def clothing_item_result_links\n if @country != DE\n @browser.div(:id => \"ctl00_contentBody_productListingSection\").links(:class => \"img\")\n else\n @browser.div(:id => \"ctl00_contentBody_productListingSection\").links(:class => \"img\")\n end\n end",
"def href\n vcloud_attributes[:href]\n end",
"def vanity_url\n branch_vanity_url = name.downcase.gsub(/[a-z ]+/).to_a.join('').split(' ').join('-')\n company_vanity_url = self.agent.name.downcase.gsub(/[a-z ]+/).to_a.join('').split(' ').join('-')\n Rails.configuration.frontend_production_url + '/branches/details/' + [ company_vanity_url, branch_vanity_url, self.id.to_s ].join('-')\n end",
"def resource_attribute_value(attribute, value)\n linked_attributes = [:member_of_collections, :decorated_numismatic_monograms]\n return link_to(value.title, solr_document_path(id: value.id)) if linked_attributes.include?(attribute)\n return catalog_link(attribute, value) if attribute == :source_metadata_identifier\n\n value\n end",
"def vanity_url\n branch_name = self.branch.name.downcase.gsub(/[a-z ]+/).to_a.join('').split(' ').join('-')\n company_name = self.branch.agent.name.downcase.gsub(/[a-z ]+/).to_a.join('').split(' ').join('-')\n agent_name = name\n agent_name ||= ''\n agent_name = agent_name.downcase.gsub(/[a-z ]+/).to_a.join('').split(' ').join('-')\n Rails.configuration.frontend_production_url + '/agents/' + [ company_name, branch_name, agent_name, self.id.to_s ].join('-')\n end",
"def url(name)\n compliance_data.dig(:information_urls, name)\n end",
"def change_address_handling_page_link\n $tracer.trace(__method__)\n #unit_test_no_generate: change_address_handling_page_link, a.className(create_ats_regex_string(\"ats-changeship\"))\n return ToolTag.new(a.className(create_ats_regex_string(\"ats-changeship\")), __method__, self)\n end",
"def link_to_asset(body,model,url_opts={},html={})\n result = String.new\n result << '<a href=\"' + url_for_asset(model,url_opts) + '\">'\n result << body\n result << '</a>'\n end",
"def cta_url(cta)\n orzoro_cta_url(cta)\n end",
"def external_link(link_label, url, options={})\n attributes = options[:attributes] || {}\n children = options[:children] || {}\n image = options[:image] || {}\n\n img =\"\"\n unless image.empty?\n img = self.external_image(image[:url], image, true) \n end\n\n child_elements = self.children_list(children) << img\n link_label = self.tag('label', link_label)\n url = self.tag('url', url)\n link = self.tag('externalLink', url << link_label << child_elements, attributes)\n\n cell = options[:cell] || {}\n row = options[:row] || {}\n self.row_cell(link, cell, row)\n end",
"def logo_url\n @shop.dig('logo_url','url')\n end",
"def baseSeeAlsoUrl\n if $cnf['environment'] == 'testb'\n case\n when $cnf['datacenter'] == 'US'\n 'https://ds6-testb-www.adminsys.mrll.com/bidder/forum/see_also_prompt.do?projectId='\n end\n\n elsif $cnf['environment'] == 'stage'\n case\n when $cnf['datacenter'] == 'US'\n 'https://ds6-stage-maw.datasite.com/bidder/forum/see_also_prompt.do?projectId='\n when ($cnf['datacenter'] == 'EU') && ($cnf['teridion'] == 't-off')\n 'https://ds6-eumastage-maw.datasite.com/bidder/forum/see_also_prompt.do?projectId='\n when $cnf['teridion'] == 't-on'\n 'https://eu1w-stage.datasite.com/bidder/forum/see_also_prompt.do?projectId='\n end\n elsif $cnf['environment'] == 'stage2'\n case\n when $cnf['datacenter'] == 'US'\n 'https://ds6-stage2-maw.merrillcorp.com/bidder/forum/see_also_prompt.do?projectId='\n end\n\n elsif $cnf['environment'] == 'prod'\n case\n when $cnf['datacenter'] == 'US'\n 'https://us1.merrillcorp.com/bidder/forum/see_also_prompt.do?projectId='\n when ($cnf['datacenter'] == 'EU') && ($cnf['teridion'] == 't-off')\n 'https://eu1.merrillcorp.com/bidder/forum/see_also_prompt.do?projectId='\n when $cnf['teridion'] == 't-on'\n 'https://eu1w.merrillcorp.com/bidder/forum/see_also_prompt.do?projectId='\n end\n end\nend",
"def resource_url\n base_url + \"/dsi_\" + resource_name + \".aspx\"\n end",
"def href\n @href ||= build_href(path, collection: self.collection?)\n end",
"def link\n @link ||= uri.to_s\n end",
"def set_url\n self.update_column(:url, '/' + self.ancestry_url)\n end",
"def conditional_link(source, target = source)\n source_dir = @onabase + \"/www/local/plugins/cfg_archive/bin/\"\n target_dir = @onabase + \"/bin/\"\n\n source_file = source_dir + source\n target_link = target_dir + target\n\n FileUtils.ln_sf(source_file, target_link)\nend",
"def license_link(book)\n case book.license\n when nil\n return 'None<a class=\"btn btn-mini\" href=\"/books/' + book.id.to_s + '#license\">Choose a License</a>'\n when \"cc-by\"\n return '<a href=\"' + book.license_url + '\" class=\"linked-icon\" title=\"' + book.license_name + '\"><span class=\"icon-cc\"></span><span class=\"icon-cc-by\"></span><span class=\"cc-title\">' + book.license_name + '</span></a>'\n when \"cc-by-nd\"\n return '<a href=\"' + book.license_url + '\" class=\"linked-icon\" title=\"' + book.license_name + '\"><span class=\"icon-cc\"></span><span class=\"icon-cc-by\"></span><span class=\"icon-cc-nd\"></span><span class=\"cc-title\">' + book.license_name + '</span></a>'\n when \"cc-by-sa\"\n return '<a href=\"' + book.license_url + '\" class=\"linked-icon\" title=\"' + book.license_name + '\"><span class=\"icon-cc\"></span><span class=\"icon-cc-by\"></span><span class=\"icon-cc-sa\"></span><span class=\"cc-title\">' + book.license_name + '</span></a>'\n when \"cc-by-nc\"\n return '<a href=\"' + book.license_url + '\" class=\"linked-icon\" title=\"' + book.license_name + '\"><span class=\"icon-cc\"></span><span class=\"icon-cc-by\"></span><span class=\"icon-cc-nc\"></span><span class=\"cc-title\">' + book.license_name + '</span></a>'\n when \"cc-by-nc-sa\"\n return '<a href=\"' + book.license_url + '\" class=\"linked-icon\" title=\"' + book.license_name + '\"><span class=\"icon-cc\"></span><span class=\"icon-cc-by\"></span><span class=\"icon-cc-nc\"></span><span class=\"icon-cc-sa\"></span><span class=\"cc-title\">' + book.license_name + '</span></a>'\n when \"cc-by-nc-nd\"\n return '<a href=\"' + book.license_url + '\" class=\"linked-icon\" title=\"' + book.license_name + '\"><span class=\"icon-cc\"></span><span class=\"icon-cc-by\"></span><span class=\"icon-cc-nc\"></span><span class=\"icon-cc-nd\"></span><span class=\"cc-title\">' + book.license_name + '</span></a>'\n else\n # This is an \"Other\" license.\n # @todo, I could simplify the schema a bit by getting rid of the \"Other license\" field and just\n # allowing their custom license to be placed in the \"license\" field.\n return '<a href=\"' + Rack::Utils.escape_html(book.license_url) + '\" title=\"' + book.license_name + '\">' + Rack::Utils.escape_html(book.license_name) + '</a>'\n end\n end",
"def link uri\n self.apply_hyperlink java.net.URI.new(uri)\n end",
"def add_href\n return if attributes.key?(\"href\")\n return unless attributes.key?(\"id\")\n attributes[\"href\"] = client.connection.api_path(\"#{collection.name}/#{attributes['id']}\")\n end",
"def affiliate_url\n apparel_item.product_url\n end",
"def handle_special_HYPERLINK(special) # rubocop:disable Style/MethodName\n @hyperlink ? special.text : super\n end",
"def not_found_link\n @not_found_url ||= \"#{ENV['IMAGO_BASE_LINK_URL']}not_found.jpg\"\nend",
"def url\n super\n end",
"def hyperlink_base=(v) Axlsx.validate_string v; @hyperlink_base = v; end",
"def information_url=(value)\n @information_url = value\n end",
"def information_url=(value)\n @information_url = value\n end",
"def links\n return {} unless current_user\n\n # rubocop:disable Metrics/BlockLength\n super.tap do |links|\n links[:show] = api_asset_path(object)\n links[:user] = user_path(object.user.dxuser)\n links[:space] = space_path if object.in_space?\n\n # POST download_list asset\n links[:download_list] = download_list_api_files_path\n # POST /api/files/copy copy_api_files\n links[:copy] = copy_api_files_path\n\n if object.license.present? && object.license_status?(current_user, \"active\")\n unless object.license.owned_by_user?(current_user)\n # GET download single asset\n links[:download] = download_api_file_path(object)\n end\n end\n\n if object.license.blank? && object.owned_by_user?(current_user)\n # GET download single asset\n links[:download] = download_api_file_path(object)\n end\n\n if object.license.present? && !object.license_status?(current_user, \"active\")\n if object.license.approval_required\n unless object.license_status?(current_user, \"pending\")\n # GET|POST /licenses/:id/request_approval\n links[:request_approval_license] =\n request_approval_license_path(object.license.id)\n links[:request_approval_action] = \"api/licenses/:id/request_approval\"\n end\n else\n # POST /api/licenses/:id/accept\n links[:accept_license_action] =\n object.license && accept_api_license_path(object.license.id)\n end\n end\n\n # GET asset license page if exists\n links[:show_license] = license_path(object.license.id) if object.license\n\n if object.owned_by_user?(current_user)\n unless object.in_space? && member_viewer?\n # publish single asset if it is not public already\n links[:publish] = publish_object unless object.public?\n # POST: /api/assets/rename\n links[:rename] = rename_api_assets_path(object)\n # DELETE: /api/assets/:id - Delete single asset\n links[:remove] = api_asset_path(object)\n # POST associate item to a license\n links[:license] = \"/api/licenses/:id/license_item/:item_uid\" if licenseable\n if object.license&.owned_by_user?(current_user)\n # GET asset license object if exists\n links[:object_license] = api_license_path(object.license&.id)\n # POST detach license from item\n links[:detach_license] = \"/api/licenses/:id/remove_item/:item_uid\"\n end\n # PUT /api/assets/:id update single asset: title and description permitted\n links[:update] = api_asset_path(object)\n end\n end\n # POST /api/attach_to: api_attach_to_notes, discussions, answers\n links[:attach_to] = api_attach_to_notes_path\n\n if current_user.can_administer_site?\n # PUT /api/assets/feature #\n links[:feature] = feature_api_assets_path\n end\n # rubocop:enable Metrics/BlockLength\n end\n end",
"def to_s\r\n assert_exists\r\n super({\"href\" => \"href\",\"inner text\" => \"text\"})\r\n end",
"def additional_links\n @additional_links ||= begin\n links = {}\n\n main_link_label = ScihistDigicoll::Util.humanized_content_type(main_file.content_type)\n main_link_label << \" - \" + ScihistDigicoll::Util.simple_bytes_to_human_string(main_file.size)\n\n links[main_link_label] =\n shrine_file_url(shrine_file: main_file, disposition: \"attachment\", filename: item_filename)\n\n if flac_with_m4a?\n # add the original flac link too\n links[\"FLAC - #{ScihistDigicoll::Util.simple_bytes_to_human_string(asset.size)}\"] =\n shrine_file_url(shrine_file: asset.file,\n disposition: \"attachment\",\n filename: DownloadFilenameHelper.filename_for_asset(asset))\n end\n\n links\n end\n end",
"def banner_url\n object.banner_url.url\n end",
"def generated_url; end",
"def ui_url\n\t\t\thref\n\t\t\t\t.gsub(\"api/v1/companies\", \"foretak\")\n\t\t\t\t.gsub(\"sales\", \"handel/salg\")\n\t\tend",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def url; end",
"def addIssueBuyLink(unit, volume, issue, dbAttrs)\n key = \"#{unit}:#{volume}:#{issue}\"\n link = $issueBuyLinks[key]\n link and dbAttrs[:buy_link] = link\nend",
"def epub_sample_url\n if @collateral_detail\n @collateral_detail.epub_sample_url\n end\n end",
"def original_url; end",
"def website_url\n Organization.clean_url(read_attribute(:website_url))\n end",
"def test_CC_web_resource\n # CC -!- DATABASE: NAME=ResourceName[; NOTE=FreeText][; WWW=WWWAddress][; FTP=FTPAddress].\n # CC -!- WEB RESOURCE: NAME=ResourceName[; NOTE=FreeText]; URL=WWWAddress.\n # The length of these lines may exceed 75 characters because long URL addresses are not wrapped into multiple lines.\n assert(true)\n end",
"def contract_urls\n Scrapers::ContractUrlExtractor.new(report.url).urls\n end",
"def render_link_to_clio(args = {})\n scalar_value = !(args[:value].is_a? Array)\n clio_links = Array(args[:value]).map do |clio_id|\n link_label = \"#{args[:config].link_label || clio_id} <span class=\\\"fa fa-external-link\\\"></span>\".html_safe\n link_to(link_label, \"http://clio.columbia.edu/catalog/#{clio_id}\", target: '_blank')\n end\n scalar_value ? clio_links.first : clio_links\n end",
"def resourceType\n 'Linkage'\n end",
"def image_url_tco(link_url)\n service_url = link_url_redirect link_url\n find_image_url service_url\n end",
"def human_url\n return self.alternate_link\n end",
"def cover_url\n case self.category\n when \"Nutrition\"\n \"nutrition.jpeg\" \n when \"Activity\"\n \"activity.jpeg\"\n when \"Exercise\"\n \"exercise.jpeg\"\n when \"Rehabilitation\"\n \"rehabilitation.jpeg\"\n when \"Medication\"\n \"medications.jpeg\"\n else\n \"activity.jpeg\"\n end\n end",
"def preferred_url(e)\n if !e.url.blank?\n url_escape(e.url.address)\n else\n \"https://www.contactimprov.net/events/view/#{e.id}\"\n end\n end",
"def attribution\n title = name && !name.empty? ? \"<cite>#{name}</cite>\" : \"Photo\"\n licensing_info = \n if license\n \", licensed under <a href='#{@@license_links[license]}'>#{license}</a>\"\n else\n nil\n end\n \"<a href='#{image_address}'>#{title}</a> by \n <a href='#{author_address}'>#{author_name}</a>#{licensing_info}</a>\"\n end",
"def footer_corporate_information_link\n $tracer.trace(__method__)\n return ToolTag.new(div.className(\"business\").a.at(5), __method__)\n end",
"def url\n deposit.ore_url.chomp('#aggregation').gsub('oremap', 'status')\n end",
"def item_link(record)\n doi_link = doi_generator(record)\n\n # Return DOI link, in one exists\n return doi_link if doi_link\n\n # Query OpenURL resolve service for results\n open_url_links = open_url_generator(record)\n if open_url_links.size.positive?\n # If there is only one result, return it\n return open_url_links[0] if open_url_links.size == 1\n\n # If there are multiple results, return a \"Citation Finder\" link\n return citation_generator(record)\n end\n\n # Default -- return link to the catalog detail page\n catalog_generator(record)\n end",
"def url\n if super=~/ticketmaster.com/\n return \"http://ticketsus.at/tourfilter?CTY=37&DURL=#{super}\"\n else\n return super\n end\n end",
"def test_outbound_link\r\n checker=ConsistencyChecker.new(\r\n @linkfinder,\r\n uriFromTest(\"url_retriever/test.htm\")\r\n )\r\n res=newResponse :body=> <<EOF\r\n<html>\r\n<head>\r\n<title>Consistency checker -- foreign domain test</title>\r\n</head>\r\n<body>\r\n<p>This is an example.com domain.</p>\r\n<a href=\"testB.htm\">Test 2</a>\r\n</body>\r\n</html>\r\nEOF\r\n links=checker.check(URI(\"http://www.example.com\"),res)\r\n assert links.empty?\r\n end",
"def link_standard_from_code(to, from)\n to.source = from.container.url\n to.id = from.id\n to.uri = from.uri\n to.prefix = from.container.id\n to.title = from.title\n to.description = from.description\n to.pattern = from.pattern\nend",
"def href\n resource_desc = service_description['resources'].find{|r| r['name'] == resource_name} || \n raise(NoSuchResource, \"#{resource_name} resource is not exposed by the <#{service_type}> service\")\n \n resource_desc['href']\n end",
"def edit_cart_link\n $tracer.trace(__method__)\n #unit_test_no_generate: edit_cart_link, a.className(create_ats_regex_string(\"ats-cartedit\"))\n return ToolTag.new(a.className(create_ats_regex_string(\"ats-cartedit\")), __method__, self)\n end",
"def url\n raise \"Implement in child class\"\n end",
"def loc_tag(output_file, url)\n write output_file, \"<url>\"\n write output_file, \"\\t<loc>#{url}</loc>\"\n yield\n write output_file, \"</url>\"\n end"
] |
[
"0.55972606",
"0.55344504",
"0.55250597",
"0.5484369",
"0.54650277",
"0.54366934",
"0.53981376",
"0.53907686",
"0.5372756",
"0.53431016",
"0.5312575",
"0.5293552",
"0.5248956",
"0.52340806",
"0.5197136",
"0.5188058",
"0.5169922",
"0.51620907",
"0.5158144",
"0.51543087",
"0.51367235",
"0.51367235",
"0.51227653",
"0.5096655",
"0.5096655",
"0.5085758",
"0.507543",
"0.5073345",
"0.5072022",
"0.5070736",
"0.50511533",
"0.50083447",
"0.50067276",
"0.4996197",
"0.49850196",
"0.49788162",
"0.4976397",
"0.49763757",
"0.49743238",
"0.49739227",
"0.4964724",
"0.49609068",
"0.4959309",
"0.49583554",
"0.49570584",
"0.49454874",
"0.49354875",
"0.49335504",
"0.4922548",
"0.49151194",
"0.49095973",
"0.49095973",
"0.49004987",
"0.4897688",
"0.4895577",
"0.48883858",
"0.4885435",
"0.48804426",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.48794284",
"0.4879342",
"0.48773175",
"0.48721692",
"0.486512",
"0.48624584",
"0.48524466",
"0.48519284",
"0.48428705",
"0.4840088",
"0.48296192",
"0.4827473",
"0.4822498",
"0.48216707",
"0.48212063",
"0.4809161",
"0.48070085",
"0.48037082",
"0.47998127",
"0.4798372",
"0.47977892",
"0.4795883",
"0.47958753",
"0.47925767"
] |
0.55700177
|
1
|
add info specific to an item type.
|
def generate_rdf_specific(b,ty)
case ty
when 'thesis'
th = setup_thesis_info(to_marc)
typ = th[:type].to_s
Rails.logger.debug "********es287_dev #{__FILE__} #{__LINE__} #{__method__} #{th.inspect}"
b.z(:type,typ)
else
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def add_type\n @item.type = bibtex_type\n end",
"def add(type, description, options={})\n type = type.downcase\n if type == 'todo' then @items.push TodoItem.new(description, options) #uses ToDoItem class in todo.rb\n elsif type == 'event' then @items.push EventItem.new(description, options) #uses EventItem class in event.rb\n elsif type == 'link' then @items.push LinkItem.new(description, options) #usesLinkItem class in event.rb\n else raise UdaciListErrors::InvalidItemType,\n \"'#{type}' is not a valid data type\" #raise error if type is not one of the 3 required\n end\n end",
"def add(type, description, options={})\n type = type.downcase\n add_item construct_item(type, description, options)\n end",
"def add_type(type)\n end",
"def add(type, thing, quantity=0)\n # Add a new type if it does not already exist.\n @items[type] = [] if !@items.has_key?(type)\n\n list_by_type = @items[type]\n if list_by_type.is_a? Array then\n list_by_type.push(thing)\n elsif list_by_type.has_key?(thing) then\n list_by_type[thing] += quantity\n else\n list_by_type[thing] = quantity\n end\n end",
"def add_new(type, new_item)\n #Add exercise to exercise_list\n if type == \"exercise\"\n @exercise_list.push(new_item)\n return 0\n #Add a workout to workout_routines\n elsif type == \"workout\"\n @workout_routines.push(new_item)\n return 0\n #Error handling\n else\n return -1\n end\n\n end",
"def add_type(type)\n\n # nothing to be done\n end",
"def add_type(type)\n\n # nothing to be done\n end",
"def set_item_type\n @item_type = ItemType.find(params[:id])\n end",
"def push(item_type, item)\n all(item_type).push(normalized(item))\n end",
"def set_item_type\n @item_type = ItemType.find(params[:id])\n end",
"def add_item_text(text, id, type)\n # return normal text if range is 0 or the option isn't used for this type\n return text if Items.range(id) == 0\n # get scope\n scope = $data_items[id].scope\n # iterate through configuration\n Config::ITEM_DATA_MODE.each_index {|i|\n # if current option was set up for this type\n if Config::ITEM_DATA_MODE[i] == type\n # add extra information to result text\n case i\n when 0\n next if scope == 0 || scope == 7\n text += case Items.type(id)[0]\n when SHOOT then Cache::ScopeOne.include?(scope) ? ' (Shooter)' : ' (Thruster)'\n when HOMING then Cache::ScopeOne.include?(scope) ? ' (Homing)' : ' (S. Homing)'\n when DIRECT then Cache::ScopeOne.include?(scope) ? ' (Selector)' : ' (Shockwave)'\n when BEAM then Cache::ScopeOne.include?(scope) ? ' (Beam)' : ' (Fullscreen)'\n when TRAP then ' (Trap)'\n when TIMED then ' (Timed)'\n when SUMMON then ' (Summoner)'\n end\n when 1 then text += ' (explodes)' if Items.type(id)[1] > 0\n when 2\n number = Items.range(id)\n number = 1.0 if number < 1.0\n text += \" R: #{number}\"\n end\n end}\n # return result text\n return text\n end",
"def add_shop_good(good_id, item_type, item_id, price=nil)\n if item_type == :item\n item_type = 0\n elsif item_type == :weapon\n item_type = 1\n elsif item_type == :armor\n item_type = 2\n end\n price_type = price ? 1 : 0\n custom_goods[good_id] = [item_type, item_id, price_type, price]\n end",
"def add_info(info)\n self.info.push info\n end",
"def add_item(item)\n item.item_number = @@item_number\n @@item_number += 1\n @grocery_item << item\n\n # starting the logic for finding out what type of item it is and if it will be\n # allowed to be taxed. < -- Continue here\n if @grocery_item.item_type == \"books\"\n\n end\n\n\n\nend",
"def <<(itm)\n items << convert_to_type(itm)\n end",
"def lookup_item_type\n @item_type = ItemType.find(params[:item_type_id])\n end",
"def add_type(type)\n\n # does nothing, types are differentiated by the 'typ' column\n end",
"def add_type(type)\n\n # does nothing, types are differentiated by the 'typ' column\n end",
"def item\n item_type.name.classify.constantize.find(item_id)\n end",
"def saw_item(item); end",
"def add_item(item)\n @items[item.name] ||= []\n @items[item.name] << item\n end",
"def set_itemtype\n @itemtype = Itemtype.find(params[:id])\n end",
"def add!(item)\n @ckh[item.class][item] = item\n end",
"def info_for(item)\n # Create quantity & trucks hash for this item\n {\n quantity: quantity_for(item),\n food_trucks: food_trucks_that_sell(item.name)\n }\n end",
"def item=(new_item)\n @item = new_item\n self.item_id = @item.id\n self.item_type = new_item.class.name.classify\n end",
"def find_item_type\n if params[:item_type].in? ['contact', 'organization', 'project', 'event']\n @item_type = params[:item_type]\n end\n end",
"def find_item_type\n if params[:item_type].in? ['contact', 'organization', 'project', 'event']\n @item_type = params[:item_type]\n end\n end",
"def add_item(item)\n @get_items << item\n end",
"def add_item(item)\n @inventory.push(item)\n if item.include? \"weapon\"\n @weapon = item\n end\n end",
"def add_item(item)\n item = Item.find item unless item.is_a? Item\n $logger.debug{\"#{self} add #{item}\"}\n items << item\n inventory << item.id\n item\n end",
"def item_type_params\n params[:item_type]\n end",
"def add_item(item)\n @chores << item\n end",
"def set_vendor_item_type\n @vendor_item_type = VendorItemType.find(params[:id])\n end",
"def add(content_type, attributes)\n _attributes = self.filter_attributes(content_type, attributes)\n\n entry = content_type.build_entry(_attributes)\n\n key = File.join(content_type.slug, entry._slug)\n\n self.items[key] = self.ids[entry._id] = entry\n end",
"def typed_add(element)\n if element.kind_of?(REXML::Element)\n\n if element.name == 'item'\n super(DiscoItem::new.import(element))\n else\n super(element)\n end\n\n else\n super(element)\n end\n end",
"def set_item_attribute_type\n @item_attribute_type = ItemAttributeType.find(params[:id])\n end",
"def record_type\n attributes['item_type']\n end",
"def item_add item\n\t\tret = super\n\t\titem.known! if (ret)\n\t\treturn ret\n\tend",
"def add( item)\n\t\titem.addtag self.gettag\n\tend",
"def add_item item\n @items << item\n @@all_items << item\n end",
"def addinfo\n\nend",
"def add(type)\n @list << type\n self\n end",
"def add_item(new_item)\n item = Item.new(new_item)\n items.push(item)\n end",
"def construct_item type, description, options\n type = type.downcase\n if type_allowed? type\n # Create and return a new item of the type passed in\n @@list_types[type.to_sym].new(description, options)\n else\n # Raise the invalid item type error if the type does not exist\n raise UdaciListErrors::InvalidItemType if !type_allowed? type\n end\n end",
"def addItem(item)\n @items << item\n end",
"def add_item\n\t\tputs \"Welcome to the Jones market\"\n\t\tputs \" \"\n\t\tputs \"please input product name\"\n\t\tproduct_name = gets.chomp\n\t\tputs \"please input the price\"\n\t\tprice = gets.chomp.to_i\n\n\t\tproduct_type(product_name, price)\n\tend",
"def add(item)\n @ckh[item.class][item] ||= item\n end",
"def create\n @itemtype = Itemtype.new(itemtype_params)\n\n respond_to do |format|\n if @itemtype.save\n format.html { redirect_to @itemtype, notice: 'Itemtype was successfully created.' }\n format.json { render :show, status: :created, location: @itemtype }\n else\n format.html { render :new }\n format.json { render json: @itemtype.errors, status: :unprocessable_entity }\n end\n end\n end",
"def typed_add(element)\n if element.kind_of?(REXML::Element) && (element.name == 'item')\n super(XRosterItem::new.import(element))\n else\n super(element)\n end\n end",
"def add_info( info_attributes = {})\n info = Info.new( info_attributes )\n self.infos << info\n info\n end",
"def add_item(item_list, item, qty)\r\n item_list[item] = qty\r\n item_list\r\nend",
"def add_classification\n @bib.classification.each do |c|\n case c.type\n when \"type\" then @item[\"type\"] = c.value\n when \"mendeley\" then @item[\"mendeley-tags\"] = c.value\n end\n end\n end",
"def add_item (grocery, item_name, quantity)\n grocery[item_name] = quantity\n display_list(grocery)\n end",
"def add(name, type, offset = nil)\n if type.respond_to?(:to_str) || type.respond_to?(:to_sym)\n type = registry.build(type.to_s)\n end\n @fields << [name.to_s, type, offset]\n end",
"def create\n @item_type = ItemType.new(params[:item_type])\n\n respond_to do |format|\n if @item_type.save\n format.html { redirect_to(:action => 'new', :notice => I18n.t(\"views.notice.model_create\", :model => ItemType.model_name.human)) }\n format.xml { render :xml => @item_type, :status => :created, :location => @item_type }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @item_type.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def add\n\n item = params[:item]\n type = params[:type]\n\n added = nil\n\n if type=='song'\n\n if Favorite.exist_song(item, user_signed_in?, current_user)\n added = Song.quit_favorite(item, user_signed_in?, current_user)\n else\n added = Song.add_favorite(item, user_signed_in?, current_user)\n end\n \n end\n\n if type=='movie'\n\n year = item['year']\n name = item['name']\n\n if Favorite.exist_movie(year, name, user_signed_in?, current_user)\n added = Movie.quit_favorite(item, user_signed_in?, current_user)\n else\n added = Movie.add_favorite(item, user_signed_in?, current_user)\n end\n\n end\n\n response = {\n :added => added,\n }\n \n render :json =>response\n \n end",
"def typed_add(element)\n if element.kind_of?(REXML::Element) && (element.name == 'item')\n item = RosterItem::new.import(element)\n super(item)\n else\n super(element)\n end\n end",
"def add_item(barcode, name, price)\n @barcodes << barcode\n @names << name\n @prices << price\n end",
"def add(item)\n self[to_identifier(item)] = item\n end",
"def determine_item(item_type, item_id)\n case item_type\n \n when \"weapon_id\"\n Weapon.find(item_id) \n when \"armor_id\"\n Armor.find(item_id)\n when \"potion_id\"\n Potion.find(item_id)\n end\n end",
"def add_item(new_item)\n item = Item.new(new_item)\n @items.push(item)\n end",
"def item_type_id(item)\n case item\n when RPG::Item\n return 1\n when RPG::Weapon\n return 2\n when RPG::Armor\n return 3\n else\n return 0\n end\n end",
"def add(attributes)\n slug = attributes['slug']\n\n attributes.delete('entries_custom_fields').each do |_attributes|\n _attributes = _attributes.delete_if { |k, v| v.blank? || %w(id updated_at created_at).include?(k) }\n\n # TODO: select options\n\n (attributes['fields'] ||= []) << _attributes\n end\n\n unless self.items.key?(slug)\n self.items[slug] = Locomotive::Mounter::Models::ContentType.new(attributes)\n end\n\n self.items[slug]\n end",
"def item_type\n name.singularize.ns_underscore\n end",
"def addMetadataType\n begin\n # Name of the metadatatype to be added\n name = params[:metadatatypename].to_s.strip.downcase\n value_type = params[:value_type].to_s.strip.downcase\n\n if value_type == \"\"\n value_type = \"string\"\n elsif value_type != \"string\" && value_type != \"float\" && value_type != \"date\" && value_type != \"datetime\"\n render :text => \"Invalid value_type\", :status => 404\n return\n end\n\n # Check that type doesn't exist already\n # @@existing_metadata_types listed in the beginning of file\n if MetadataType.find_by_name(name) or @@existing_metadata_types.include?(name)\n render :text => \"Metadatatype already exists\", :status => 200\n return\n end\n\n # Create new type\n @newtype = MetadataType.create(:name => name, :value_type => value_type)\n render :text => \"Metadatatype created\", :status => 201\n return\n rescue => e\n puts \"Error in adding metadatatype: #{e.to_s}\".background(:red)\n render :text => \"Conflict\", :status => 409\n return\n end\n end",
"def <<(item)\n add_item(item)\n end",
"def update_info\n if @compact_mode == :enabled\n @info_compact.show_item(@item_list[@index])\n else\n @info_wide.show_item(@item_list[@index])\n end\n end",
"def create\n @item_attribute_type = ItemAttributeType.new(item_attribute_type_params)\n\n if @item_attribute_type.save\n render :show, status: :created, location: @item_attribute_type\n else\n render json: @item_attribute_type.errors, status: :unprocessable_entity\n end\n end",
"def add_item(item)\n\t\t@items.push(item)\n\tend",
"def item_class\n item_type&.classify&.constantize\n end",
"def generate_itemdef_data(type,name)\n generate_itemdef_line(type,name,true,false)\n end",
"def add_item(list,item_name, qty)\n list[item_name] = qty\nend",
"def create\n @item_type = ItemType.new(item_type_params)\n\n respond_to do |format|\n if @item_type.save\n format.html { redirect_to @item_type, notice: 'ItemType was successfully created.' }\n format.json { render action: 'show', status: :created, location: @suplier }\n else\n format.html { render action: 'new' }\n format.json { render json: @item_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def item_type_params\n params.require(:item_type).permit(:name, :string, :base_fee, :fee_per_day, :disclaimer)\n end",
"def add_item(item, quantity, list)\n\tlist[item] = quantity\n\titem\nend",
"def add(attributes)\n slug = attributes['slug']\n\n # TODO: raise an error if no fields\n\n attributes.delete('fields').each_with_index do |_attributes, index|\n hash = { name: _attributes.keys.first, position: index }.merge(_attributes.values.first)\n\n if options = hash.delete('select_options')\n hash['select_options'] = self.sanitize_select_options(options)\n end\n\n (attributes['fields'] ||= []) << hash\n end\n\n attributes[:mounting_point] = self.mounting_point\n\n unless self.items.key?(slug)\n self.items[slug] = Locomotive::Mounter::Models::ContentType.new(attributes)\n end\n\n self.items[slug]\n end",
"def create\n @receipt_item_type = current_account.receipt_item_types.create(receipt_item_type_params)\n if @receipt_item_type\n respond_with @receipt_item_type do |format|\n format.json { render :json => current_account.receipt_item_types.include_names.find(@receipt_item_type.id) }\n end\n else\n respond_with @receipt_item_type\n end\n end",
"def add(type)\n merge(type.registry.minimal(type.name))\n nil\n end",
"def item\n case item_type\n when 'group'\n group\n end\n end",
"def item\n case item_type\n when 'group'\n group\n end\n end",
"def add_item(grocery_list, item, quantity = 1)\n \tgrocery_list[item.to_sym] = quantity\nend",
"def add_item\n @item =\n if params[:cart_type].eql? 'product'\n Product.find_by(id: params[:product_id])\n elsif params[:cart_type].eql? 'junkyard'\n JunkyardProduct.find_by(id: params[:product_id])\n end\n\n if @item\n @user.carts.where(product_id: @item, aasm_state: params[:cart_type]).first_or_create\n else\n @object = 'Product or Junkyard'\n render \"api/v1/errors/404\", status: 401\n end\n end",
"def add_items(items)\n add_items!(unknown_items(items))\n end",
"def add_item(item)\n if (@items.has_key?(item.id))\n #raise error here\n end\n @items[item.id] = item\n Event::ItemUpdateEvent.item_created item\n end",
"def add_item(list, item_name, quantity)\n list[item_name.to_sym] = quantity\n list \nend",
"def make_item(object_type_name)\n\n ot = ObjectType.find_by(name: object_type_name)\n raise \"Could not find object type #{name}\" unless ot\n\n Item.make({ quantity: 1, inuse: 0 }, sample: self, object_type: ot)\n\n end",
"def add_variant_with_gift_package(variant, quantity = 1, gift_package_id = nil)\n current_item = contains?(variant)\n if current_item\n current_item.quantity += quantity\n current_item.gift_package_id = gift_package_id\n current_item.save\n else\n current_item = Spree::LineItem.new(:quantity => quantity)\n current_item.variant = variant\n current_item.price = variant.price\n current_item.gift_package_id = gift_package_id\n self.line_items << current_item\n end\n\n # populate line_items attributes for additional_fields entries\n # that have populate => [:line_item]\n Spree::Variant.additional_fields.select { |f| !f[:populate].nil? && f[:populate].include?(:line_item) }.each do |field|\n value = ''\n\n if field[:only].nil? || field[:only].include?(:variant)\n value = variant.send(field[:name].gsub(' ', '_').downcase)\n elsif field[:only].include?(:product)\n value = variant.product.send(field[:name].gsub(' ', '_').downcase)\n end\n current_item.update_attribute(field[:name].gsub(' ', '_').downcase, value)\n end\n\n current_item\n end",
"def add_new_item(new_item)\n @items.push(new_item)\n end",
"def create\n @vendor_item_type = VendorItemType.new(vendor_item_type_params)\n\n respond_to do |format|\n if @vendor_item_type.save\n format.html { redirect_to @vendor_item_type, notice: 'Vendor item type was successfully created.' }\n format.json { render :show, status: :created, location: @vendor_item_type }\n else\n format.html { render :new }\n format.json { render json: @vendor_item_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def item_transaction(item, character)\n \n case item.class.name\n\n when \"Weapon\"\n item.inventory = character.inventory\n character.inventory.weapons << item\n when \"Armor\"\n item.inventory = character.inventory\n character.inventory.armors << item\n when \"Potion\"\n item.character = character\n character.potions << item\n else\n \"Error\"\n end\n character.update(:gold => (character.gold - item.cost))\n end",
"def add_additional(name, type, klass)\n self.payload += self.add_record(name, type, klass).encode\n self.additional_rr += 1\n end",
"def create\r\n @item_type = ItemType.new(params[:item_type])\r\n\r\n respond_to do |format|\r\n if @item_type.save\r\n flash[:notice] = 'ItemType was successfully created.'\r\n format.html { redirect_to(@item_type) }\r\n format.xml { render :xml => @item_type, :status => :created, :location => @item_type }\r\n else\r\n format.html { render :action => \"new\" }\r\n format.xml { render :xml => @item_type.errors, :status => :unprocessable_entity }\r\n end\r\n end\r\n end",
"def create\n @item = \"Vger::Resources::#{params[:item][:item_type]}\".constantize.new(params[:item])\n respond_to do |format|\n if @item.save\n format.html { redirect_to suitability_item_path(@item), notice: 'Suitability Item was successfully created.' }\n format.json { render json: @item, status: :created, location: @item }\n else\n format.html { render action: \"new\" }\n format.json { render json: @item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @item_type = ItemType.find(params[:id])\n\n respond_to do |format|\n if @item_type.update_attributes(params[:item_type])\n format.html { render :action => 'edit', :notice => 'Item type was successfully updated.' }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @item_type.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def add_item(list, item, quant)\n list[item] = quant\nend",
"def add_item(name, annotation, content, avaliability, units, userId)\r\n @newInstance = Ingredience.new\r\n @newInstance.name = name;\r\n @newInstance.annotation = annotation\r\n @newInstance.content = content\r\n @newInstance.avaliability = avaliability\r\n @newInstance.units = units;\r\n @newInstance.user_id = userId;\r\n @newInstance.activation_state = 1;\r\n\r\n @newInstance.save\r\n end",
"def print(item_type)\n @item_type = item_type\n render :print\n end",
"def add(item)\n raise I18n.t('error.bad_class') unless item.instance_of?(Item)\n raise I18n.t('error.empty') if item.empty?\n\n @data.push(item)\n end",
"def add_order(order_item, qty, order)\r\n if order_item == \"latte\"\r\n item = Item.new(\"latte\", $latte_cost, $latte_price)\r\n elsif order_item == \"tea\"\r\n item = Item.new(\"tea\", $tea_cost, $tea_price)\r\n elsif order_item == \"scones\"\r\n item = Item.new(\"scones\", $scones_cost, $scones_price)\r\n end\r\n order.add_item(item, qty)\r\nend",
"def vendor_item_type_params\n params.require(:vendor_item_type).permit(:name, :description, :vendor_item_id, :active, :quote_request_item_id)\n end"
] |
[
"0.7269015",
"0.67680913",
"0.6578306",
"0.64838266",
"0.63886726",
"0.6326152",
"0.63034403",
"0.63034403",
"0.6257325",
"0.6180453",
"0.60943633",
"0.607539",
"0.60279316",
"0.60252964",
"0.60067475",
"0.6005773",
"0.60036635",
"0.58729863",
"0.58678126",
"0.58525",
"0.5826362",
"0.5810595",
"0.5803868",
"0.5793585",
"0.57814956",
"0.57711875",
"0.5770564",
"0.5770564",
"0.57441175",
"0.57395333",
"0.57367796",
"0.5729846",
"0.5723836",
"0.5718236",
"0.5716648",
"0.57130885",
"0.5712107",
"0.5703172",
"0.5675115",
"0.5665343",
"0.5657833",
"0.5651217",
"0.5649441",
"0.5642904",
"0.56379044",
"0.5596802",
"0.5583735",
"0.5576205",
"0.5566014",
"0.55544704",
"0.5552906",
"0.55471706",
"0.5546329",
"0.55426073",
"0.55343187",
"0.5529513",
"0.55190605",
"0.5514579",
"0.55078024",
"0.5507747",
"0.5499565",
"0.5499079",
"0.54935175",
"0.54870814",
"0.54828364",
"0.5482826",
"0.5472609",
"0.54636985",
"0.5455975",
"0.5452325",
"0.545232",
"0.5444179",
"0.54334927",
"0.54304713",
"0.5418335",
"0.5415969",
"0.54147",
"0.54140216",
"0.5403142",
"0.5399716",
"0.5399716",
"0.53851765",
"0.5382496",
"0.537597",
"0.5374056",
"0.5372837",
"0.5367366",
"0.5362654",
"0.5351435",
"0.53506374",
"0.5340161",
"0.53392965",
"0.53384244",
"0.5338172",
"0.532746",
"0.532551",
"0.53233683",
"0.5322806",
"0.53217983",
"0.5320527",
"0.53179145"
] |
0.0
|
-1
|
GET /cms/pages GET /cms/pages.json
|
def index
@cms_pages = Cms::Page.all
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def index\n @pages = current_site.pages\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def get_pages(options = nil)\n @client.raw('get', '/content/pages', options)\n end",
"def index\n @pages = Page.page params[:page]\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = current_cms.pages.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def index\n @pages = Page.all\n render json: @pages\n end",
"def index\n @cms_pages = CmsPage.all\n end",
"def index\n @cms_pages = current_portal.pages\n end",
"def index\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n\t\t@pages = Page.order('created_at DESC').all\n\n\t\trespond_to do |format|\n\t\t\tformat.html #index.html.erb\n\t\t\tformat.json { render json: @pages }\n\t\tend\n\tend",
"def pages\n get(\"v1/account/#{@email}/pages\")\n end",
"def index\n @pages = Page.all\n \n respond_to do |format|\n format.json { render :json => @pages }\n format.xml { render :xml => @pages }\n end\n end",
"def get_page\n render_page_sections_json\n end",
"def pages\n get(\"v1/event/#{@id}/pages\")\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.json { render json: @pages }\n format.xml { render xml: @pages }\n end\n end",
"def index\n @about_pages = AboutPage.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @about_pages }\n end\n end",
"def index\n @sites = current_user.sites.page(params[\"page\"])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @sites }\n end\n end",
"def index\n\n # find all pages\n @pages = Page.all\n\n # send data in different format\n respond_to do |format|\n format.html{render :template => 'mcms_pages/admin/pages/index'}# index.html.erb\n format.json { render json: @pages }\n end # end respond_to\n\n end",
"def index\n @static_pages = StaticPage.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @static_pages }\n end\n end",
"def index\n @static_pages = StaticPage.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @static_pages }\n end\n end",
"def index\n @pages = Page.paginate(page: params[:page])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: Page.roots.map{|r| r.node}}\n end\n end",
"def index\n @pages = Page.all\n\n respond_with @pages\n end",
"def new\n @page = current_site.pages.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def get_page(id)\n @client.raw('get', \"/content/pages/#{id}\")\n end",
"def index\n @cms_page_sections = Cms::PageSection.all\n end",
"def index\n @pages = @comic.pages\n \n respond_to do |format|\n format.html\n format.xml\n end\n end",
"def index\n @urls = @site.urls.paginate(:page => params[:page])\n render json: @urls\n end",
"def index\n @pages = Page.all\n respond_with(@pages)\n end",
"def index\n @pages = Page.all\n respond_with(@pages)\n end",
"def index\n @pages = Page.all\n respond_with(@pages)\n end",
"def index\n respond_with(pages)\n end",
"def pages\n end",
"def children\n @pages = @page.children\n \n respond_to do |format|\n format.json { render :json => @pages }\n format.xml { render :xml => @pages }\n end\n end",
"def pages\n @pages \n end",
"def show\n if admin?\n @page = Page.find_by_slug(params[:id]) \n else\n @page = Page.published.find_by_slug(params[:id]) \n end\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page, :only => [:title, :content] }\n end\n end",
"def index\n #Page.all is fine for small sets of data, for larger sets pagination would be best\n @pages = data_cache('pages', 10.minutes) do\n Page.all\n end\n respond_to do |format|\n format.json { render action: 'index', status: :ok, location: api_pages_url(@pages) }\n format.xml { render xml: @pages, location: api_pages_url(@pages) }\n end\n end",
"def show\n render json: @page\n end",
"def pages\n @pages ||= get_pages\n end",
"def index\n @pages = @user.pages\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def index\n @sites = Site.paginate(:page=>params[:page])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @sites }\n end\n end",
"def published\n @pages = Page.published\n\n respond_to do |format|\n format.json {render json: @pages}\n format.xml {render xml: @pages}\n end\n end",
"def pages\n @pages\n end",
"def pages\n @pages\n end",
"def index\n @pages = Page.all\n\n respond_to do |format| \n format.json {render json: @pages}\n format.xml {render xml: @pages}\n end\n\n end",
"def pages()\n get('subAccountPages')\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def show\n @pages_article = PagesArticle.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @pages_article }\n end\n end",
"def public_pages\n\n pages = {}\n\n # Add page contents\n ContentManagerSystem::Content.all(:type => {:id => 'page'}).map do |content| \n pages.store(content.title, content.alias)\n end \n\n # Add views\n ContentManagerSystem::View.all(:block => false).map do |view|\n pages.store(view.title, view.url)\n end\n\n return pages\n\n end",
"def show\n @pages = @admin_channel.pages.order('updated_at DESC').page(params[:page])\n end",
"def index\n @pages = SitePage.joins(:site)\n .where(sites: {slug: params[:site_slug]})\n .order(params[:order] || 'created_at ASC')\n\n site = Site.find_by(slug: params[:site_slug])\n admin = current_user.admin? || user_site_admin?(site.id)\n\n @formattedPages = @pages.map do |page|\n delete = if !admin\n {'value' => nil}\n else\n if page.deletable?\n {'value' => management_site_site_page_path(page.site.slug, page), 'method' => 'delete'}\n else\n {'value' => nil}\n end\n end\n\n res = {\n 'title' => {'value' => page.name, 'searchable' => true, 'sortable' => true, 'link' => { 'url' => page.site.routes.first.host_with_scheme + page.url, 'external' => true }},\n 'url' => {'value' => page.url, 'searchable' => true, 'sortable' => true},\n 'type' => {'value' => page.content_type_humanize, 'searchable' => false, 'sortable' => true},\n 'enabled' => {'value' => page.enabled},\n 'enable' => page.disableable? ? \\\n {'value' => toggle_enable_management_site_site_page_path(page.site.slug, page), 'method' => 'put'} : \\\n {'value' => nil},\n 'edit' => {'value' => edit_management_site_site_page_page_step_path(page.site.slug, page, :position), \\\n 'method' => 'get'},\n 'delete' => delete\n }\n\n res\n end\n\n # keep this for now, untill backbone is removed, we still need it\n gon.pages = @formattedPages\n\n respond_to do |format|\n format.html { render :index }\n format.json { render json: @pages }\n end\n end",
"def new\n @page = current_cms.pages.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @page }\n end\n end",
"def index\n @pages = Static.all\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html {render :layout => \"layout_1\"}\n format.json { render json: @pages }\n end\n end",
"def pages; end",
"def index\n @links = Link.paginate(page: params[:page])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @links }\n end\n end",
"def pages\n @pages ||= Transit::Page.roots.order('name ASC').all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @admin_pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n end\n end",
"def index\n @enq_pages = EnqPage.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @enq_pages }\n end\n end",
"def index\n @pages = @club.all_pages\n \n @page_title = \"Page Listing\"\n @site_section = \"clubs\"\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end \n end",
"def show\n @pages = Page.all\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page, :only => [:title, :content] }\n end\n end",
"def index\n @page_pages = PagePage.all\n end",
"def index\n @pages = @store.pages.active\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def index\n @pages = Page.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @page }\n end\n end",
"def list_pages(pages)\n pages.inject(''.html_safe) do |html, page|\n html << render(\n partial: page_partial(page),\n locals: {\n page: page,\n children: sitemap_children_for(page),\n }\n )\n end\n end",
"def index\n @pages = Page.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def index\n @pages = Page.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def show\n if params[:id]\n @page = current_site.pages.find(params[:id])\n else\n @page = current_site.pages.first()\n end\n @post = Post.new\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def show\n @Page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @Page }\n end\n end",
"def view\n \t@parent = params[:parent]\n\n @pages = Page.where(\"digital_edition_id = ?\", @parent).order(\"page_page ASC\").page( params[:page]).per(20)\n\n respond_to do |format|\n format.html # view.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = @site.pages.find(params[:id]).in(params[:page_locale])\n respond_with(:site, @page)\n end",
"def index\n return check_logged_in unless current_user\n @pages = current_user.pages\n end",
"def index\n (redirect_to published_site_pages_path(search: params[:search]) unless current_user) and return\n @pages = get_pages \n respond_with(:site, @page) do |format|\n if(params[:template])\n format.js { render \"#{params[:template]}\" }\n end\n end\n end",
"def get_page_contents()\n JSON.parse( \n @client.api.get(\"#{@client.base_uri.path}/api.php?#{URI.encode_www_form({\n :action => 'query',\n :prop => 'info|revisions',\n :titles => BAN_PAGE,\n :rvprop => 'content',\n :intoken => 'edit',\n :indexpageids => 1,\n :format => 'json',\n :cb => rand(1000000)\n })}\", @headers).body,\n :symbolize_names => true\n )[:query]\n end"
] |
[
"0.80024236",
"0.7591794",
"0.7548563",
"0.7502745",
"0.7413682",
"0.72976756",
"0.7275709",
"0.727428",
"0.7253506",
"0.7253506",
"0.7253506",
"0.7253506",
"0.7253506",
"0.7253506",
"0.7253506",
"0.7227317",
"0.70825803",
"0.70712346",
"0.7023665",
"0.7011868",
"0.7003465",
"0.7000448",
"0.6985622",
"0.69493747",
"0.6877466",
"0.6877466",
"0.68735045",
"0.68483686",
"0.6822072",
"0.6809814",
"0.6795047",
"0.67771673",
"0.6765212",
"0.67598647",
"0.67598647",
"0.6738969",
"0.67199826",
"0.6690739",
"0.66870666",
"0.66574234",
"0.665528",
"0.66521776",
"0.6645716",
"0.6643588",
"0.6636437",
"0.6627922",
"0.6616302",
"0.6603598",
"0.659326",
"0.6585764",
"0.65635073",
"0.6561591",
"0.6561591",
"0.6561591",
"0.6561591",
"0.6561591",
"0.6561591",
"0.6561591",
"0.6561591",
"0.6561591",
"0.6561591",
"0.6538218",
"0.6505963",
"0.64711094",
"0.64535457",
"0.6452154",
"0.6446611",
"0.6443475",
"0.6424854",
"0.6421328",
"0.6420182",
"0.6418103",
"0.64052445",
"0.6405159",
"0.64050955",
"0.64028054",
"0.6402215",
"0.6402215",
"0.6402215",
"0.6402215",
"0.6402215",
"0.6402215",
"0.6402215",
"0.6399372",
"0.6389756",
"0.6389508",
"0.638212",
"0.6380939",
"0.63717514",
"0.63717514",
"0.63667357",
"0.6364735",
"0.6351573",
"0.6351573",
"0.6328816",
"0.6328631",
"0.6313762",
"0.6289746",
"0.6283557",
"0.6279588"
] |
0.74624985
|
4
|
GET /cms/pages/1 GET /cms/pages/1.json
|
def show
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def index\n @pages = current_site.pages\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.page params[:page]\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = current_cms.pages.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def index\n @cms_pages = Cms::Page.all\n end",
"def index\n @pages = Page.all\n render json: @pages\n end",
"def index\n @cms_pages = CmsPage.all\n end",
"def get_page(id)\n @client.raw('get', \"/content/pages/#{id}\")\n end",
"def index\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def get_page\n render_page_sections_json\n end",
"def get_pages(options = nil)\n @client.raw('get', '/content/pages', options)\n end",
"def index\n @cms_pages = current_portal.pages\n end",
"def new\n @page = current_site.pages.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def index\n\t\t@pages = Page.order('created_at DESC').all\n\n\t\trespond_to do |format|\n\t\t\tformat.html #index.html.erb\n\t\t\tformat.json { render json: @pages }\n\t\tend\n\tend",
"def index\n @sites = current_user.sites.page(params[\"page\"])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @sites }\n end\n end",
"def show\n if admin?\n @page = Page.find_by_slug(params[:id]) \n else\n @page = Page.published.find_by_slug(params[:id]) \n end\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page, :only => [:title, :content] }\n end\n end",
"def index\n @about_pages = AboutPage.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @about_pages }\n end\n end",
"def index\n @pages = Page.all\n \n respond_to do |format|\n format.json { render :json => @pages }\n format.xml { render :xml => @pages }\n end\n end",
"def show\n render json: @page\n end",
"def index\n @static_pages = StaticPage.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @static_pages }\n end\n end",
"def index\n @static_pages = StaticPage.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @static_pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.json { render json: @pages }\n format.xml { render xml: @pages }\n end\n end",
"def index\n\n # find all pages\n @pages = Page.all\n\n # send data in different format\n respond_to do |format|\n format.html{render :template => 'mcms_pages/admin/pages/index'}# index.html.erb\n format.json { render json: @pages }\n end # end respond_to\n\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page, :only => [:title, :content] }\n end\n end",
"def index\n @pages = @comic.pages\n \n respond_to do |format|\n format.html\n format.xml\n end\n end",
"def show\n @pages_article = PagesArticle.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @pages_article }\n end\n end",
"def show\n @structure_page = Structure::Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @structure_page }\n end\n end",
"def index\n @pages = Page.paginate(page: params[:page])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: Page.roots.map{|r| r.node}}\n end\n end",
"def new\n @page = current_cms.pages.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @page }\n end\n end",
"def show\n @Page = Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @Page }\n end\n end",
"def show\n if params[:id]\n @page = current_site.pages.find(params[:id])\n else\n @page = current_site.pages.first()\n end\n @post = Post.new\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def index\n @cms_page_sections = Cms::PageSection.all\n end",
"def index\n @urls = @site.urls.paginate(:page => params[:page])\n render json: @urls\n end",
"def index\n @pages = Page.all\n\n respond_with @pages\n end",
"def pages\n get(\"v1/account/#{@email}/pages\")\n end",
"def pages\n get(\"v1/event/#{@id}/pages\")\n end",
"def index\n @sites = Site.paginate(:page=>params[:page])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @sites }\n end\n end",
"def show\n @page = Page.find(params[:id])\n @version = @page.versions.last\n @author = User.all\n page = {\n :version => @version.changeset,\n :body => @page.body,\n :author => @author\n }\n respond_to do |format|\n format.html\n format.json { render json: page.to_json }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html {render :layout => \"layout_1\"}\n format.json { render json: @pages }\n end\n end",
"def show\n @about_page = AboutPage.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @about_page }\n end\n end",
"def index\n @pages = Page.all\n respond_with(@pages)\n end",
"def index\n @pages = Page.all\n respond_with(@pages)\n end",
"def new\n @title = 'New Page'\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @cms_page = CmsPage.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @cms_page }\n end\n end",
"def show\n @pages = @admin_channel.pages.order('updated_at DESC').page(params[:page])\n end",
"def new\n\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def index\n @pages = Page.all\n respond_with(@pages)\n end",
"def view\n \t@parent = params[:parent]\n\n @pages = Page.where(\"digital_edition_id = ?\", @parent).order(\"page_page ASC\").page( params[:page]).per(20)\n\n respond_to do |format|\n format.html # view.html.erb\n format.json { render json: @page }\n end\n end",
"def published\n @pages = Page.published\n\n respond_to do |format|\n format.json {render json: @pages}\n format.xml {render xml: @pages}\n end\n end",
"def new\n @structure_page = Structure::Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @structure_page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @comic_page = ComicPage.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @comic_page }\n end\n end",
"def show\n @page = @site.pages.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @page }\n end\n end",
"def show\n @page = @chapter.pages.find_by_number(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def index\n #Page.all is fine for small sets of data, for larger sets pagination would be best\n @pages = data_cache('pages', 10.minutes) do\n Page.all\n end\n respond_to do |format|\n format.json { render action: 'index', status: :ok, location: api_pages_url(@pages) }\n format.xml { render xml: @pages, location: api_pages_url(@pages) }\n end\n end",
"def index\n respond_with(pages)\n end",
"def new\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def show\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.json { render json: @page }\n format.xml { render xml: @page }\n end\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n end",
"def index\n @pages = Page.all\n\n respond_to do |format| \n format.json {render json: @pages}\n format.xml {render xml: @pages}\n end\n\n end",
"def new\r\n @page = Page.new\r\n respond_to do |format|\r\n format.html # new.html.erb\r\n format.json { render json: @page }\r\n end\r\n end",
"def show\n @static_page = StaticPage.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @static_page }\n end\n end",
"def show\n @static_page = StaticPage.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @static_page }\n end\n end",
"def pages\n end",
"def show\n @page = @site.pages.find(params[:id]).in(params[:page_locale])\n respond_with(:site, @page)\n end",
"def new\n @Page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @Page }\n end\n end",
"def children\n @pages = @page.children\n \n respond_to do |format|\n format.json { render :json => @pages }\n format.xml { render :xml => @pages }\n end\n end",
"def index\n @links = Link.paginate(page: params[:page])\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @links }\n end\n end",
"def index\n @pages = @user.pages\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def show\n @page = Page.friendly.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @static_page = StaticPage.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @static_page }\n end\n end",
"def new\n @static_page = StaticPage.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @static_page }\n end\n end",
"def index\n @pages = Static.all\n end",
"def show\n @nested_page = Nested::Page.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @nested_page }\n end\n end",
"def pages\n @pages \n end"
] |
[
"0.7818136",
"0.7398596",
"0.72995096",
"0.7295045",
"0.7292579",
"0.71695435",
"0.7168041",
"0.7146733",
"0.7132539",
"0.7132539",
"0.7132539",
"0.7132539",
"0.7132539",
"0.7132539",
"0.7132539",
"0.7121467",
"0.70936114",
"0.7087248",
"0.70760006",
"0.69468063",
"0.6940699",
"0.69306827",
"0.69135827",
"0.69038427",
"0.6871521",
"0.68567806",
"0.68567806",
"0.6829799",
"0.67677104",
"0.67428327",
"0.67428327",
"0.67428327",
"0.67428327",
"0.67428327",
"0.67428327",
"0.67428327",
"0.6728483",
"0.6721782",
"0.6712433",
"0.67068887",
"0.670318",
"0.6695182",
"0.6684533",
"0.66627145",
"0.66398454",
"0.6629365",
"0.6623623",
"0.66210496",
"0.66154164",
"0.65870655",
"0.658444",
"0.657226",
"0.6534922",
"0.6532591",
"0.6532591",
"0.65107733",
"0.6505243",
"0.65000945",
"0.64967036",
"0.648935",
"0.6482492",
"0.64796937",
"0.6478624",
"0.6465562",
"0.6465562",
"0.6465562",
"0.6465562",
"0.6465562",
"0.6452621",
"0.6445086",
"0.6444389",
"0.64380527",
"0.6437856",
"0.64279145",
"0.6425042",
"0.6421391",
"0.6421391",
"0.6421391",
"0.6421391",
"0.6421391",
"0.6421391",
"0.6421391",
"0.6421391",
"0.6421391",
"0.6421391",
"0.64205813",
"0.6420548",
"0.64100647",
"0.64100647",
"0.6407367",
"0.6401514",
"0.6400818",
"0.63935006",
"0.6382502",
"0.63701063",
"0.63697535",
"0.636704",
"0.636704",
"0.63558435",
"0.63486934",
"0.63471395"
] |
0.0
|
-1
|
POST /cms/pages POST /cms/pages.json
|
def create
@cms_page = Cms::Page.new(cms_page_params)
respond_to do |format|
if @cms_page.save
if @cms_page.page_type == "Template"
format.html { redirect_to :action => "add_content", :id => @cms_page.id, notice: 'Page was successfully created.' }
else
format.html { redirect_to @cms_page, notice: 'Page was successfully updated.' }
end
format.json { render :show, status: :created, location: @cms_page }
else
format.html { render :new }
format.json { render json: @cms_page.errors, status: :unprocessable_entity }
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create\n @cms_page = current_portal.pages.build(cms_page_params)\n\n respond_to do |format|\n if @cms_page.save\n format.html { redirect_to @cms_page, notice: 'Page was successfully created.' }\n format.json { render :show, status: :created, location: @cms_page }\n else\n format.html { render :new }\n format.json { render json: @cms_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @page = current_site.pages.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def create\n @page = current_cms.pages.new(params[:big_cms_page])\n respond_to do |format|\n if @page.save\n format.html { redirect_to(@page, :notice => 'Page was successfully created.') }\n format.xml { render :xml => @page, :status => :created, :location => @page }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @page = current_site.pages.new(params[:page])\n @site = @page.site\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @cms_page = CmsPage.new(cms_page_params)\n\n respond_to do |format|\n if @cms_page.save\n format.html { redirect_to @cms_page, notice: 'Cms page was successfully created.' }\n format.json { render :show, status: :created, location: @cms_page }\n else\n format.html { render :new }\n format.json { render json: @cms_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(page_params)\n\n if @page.save\n render json: @page, status: :created, location: @page\n else\n render json: @page.errors, status: :unprocessable_entity\n end\n end",
"def create\n @page = Page.new(page_params)\n respond_to do |format|\n if @page.save\n self.build_pages_tree\n format.html { redirect_to @pages_tree[@page.id], notice: 'Page was successfully created.' }\n format.json { render :show, status: :created, location: @page }\n else\n format.html { render :new }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to [:admin, @page], notice: 'Страница успешно создана.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @page = current_cms.pages.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @page }\n end\n end",
"def create\n params[:page].except!(:map_info) unless params[:page][:map_info].present?\n @page = current_user.pages.new(params[:page])\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n @business = Business.select('id, title')\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @nested_page = Nested::Page.new(params[:nested_page])\n\n respond_to do |format|\n if @nested_page.save\n format.html { redirect_to @nested_page, notice: 'Page was successfully created.' }\n format.json { render json: @nested_page, status: :created, location: @nested_page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @nested_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to [:admin, @page], notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n #Each Page could be tied to an ApiKey or set of ApiKeys for security\n @page = Page.new(page_params)\n #Render the object created or errors\n respond_to do |format|\n if @page.save\n #Cache bust pages\n Rails.cache.delete(\"pages\")\n format.json { render action: 'show', status: :created, location: api_page_url(@page) }\n else\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n respond_to do |format|\n begin\n @page = Page.create_page!\n format.html { redirect_to \"/#{@page.request_id}/inspect\", notice: t('pages.create.success') }\n format.json { render action: 'show', status: :created, location: @page }\n rescue => e\n format.html { render action: 'index' }\n format.json { render json: {:message => \"create page error\"}, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to pages_path, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @page = ContentPage.new\n @blocks = nil\n #@newBlock = PageBlock.new\n @form_action = \"create_page\"\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def index\n @pages = current_site.pages\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def create\n @page = current_site.pages.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to quick_page_path(@page), notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n format.js\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n format.js\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n if @page.save\n respond_with(@page, location: api_pages_url)\n else\n respond_with(@page)\n end\n end",
"def create_page\n puts 'params = ' + params.inspect\n puts params[:content_page].inspect\n puts params[:content_page['name']].inspect\n @page = ContentPage.new(params[:content_page])\n puts '@page = ' + @page.inspect\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to show_content_pages_path(@page.id), notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created }\n else\n format.html { render :controller => 'content_pages', action: \"new\", alert: 'There were Errors. Could not Create a New Page.' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(admin_page_params)\n respond_to do |format|\n if @page.save\n format.html { redirect_to admin_pages_url, notice: 'page was successfully created.' }\n format.json { render :show, status: :created, location: @page }\n else\n format.html { render :new }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = current_user.pages.new(page_params)\n\n @page.slug = @page.title.parameterize\n\n if Page.exists?(slug: @page.slug, site_id: @site.id)\n pages = Page.where(title: @page.title, site_id: @site.id).count\n @page.slug = @page.title.parameterize + \"-\" + (pages + 1).to_s\n end\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to edit_page_path(@page), notice: 'Saved' }\n format.json { render action: 'show', status: :created, location: @page }\n else\n format.html { render action: 'new' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.json { render json: @page, status: :created, location: [:api, @page] }\n format.xml { render xml: @page, status: :created, location: [:api, @page] }\n else\n format.json { render json: @page.errors, status: :unprocessable_entity }\n format.xml { render xml: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n \n\n respond_to do |format|\n if @page.save\n @page.update_attribute('published_at', Time.now) if params[:commit] == 'Publish'\n \n if params[:commit] == 'Publish'\n format.html { redirect_to root_page_path(@page), notice: 'Page was successfully published.' }\n else\n format.html { redirect_to edit_page_path(@page), notice: 'Page was successfully created.' }\n end\n format.json { render json: @page, status: :created, location: @page, :only => [:title, :content] }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n if @page.save\n respond_to do |format|\n format.json {render json: @page, status: :created }\n format.xml {render xml: @page, status: :created}\n end\n \n else\n respond_to do |format|\n format.json {render json: @page.errors, status: :unprocessable_entity}\n format.xml {render xml: @page.errors, status: :unprocessable_entity}\n end\n end\n end",
"def create\n redirect_to pages_path\n end",
"def create\n params[:cms_page][:parent_id] = 0 if params[:cms_page][:parent_id].blank?\n @cms_page = CmsPage.new(params[:cms_page])\n\n respond_to do |format|\n if @cms_page.save\n expire_page \"/#{@cms_page.path}\" \n flash[:notice] = 'CmsPage was successfully created.'\n format.html { redirect_to(['admin', @cms_page]) }\n format.xml { render :xml => @cms_page, :status => :created, :location => ['admin', @cms_page] }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @cms_page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n\n # retrieve page part attributes from params and assign it to a variable\n page_parts = params[:page][:page_parts_attributes]\n\n # sort the page_parts and reassign it to the params\n params[:page][:page_parts_attributes] = Hash[page_parts.sort]\n\n #creating the page object with its own and child attributes\n @page = Page.new(params[:page])\n\n #retrieving layout id from params and assigning to a variable\n @layout = params[:page][:layout_id]\n\n # calling method to find all pages and page parts\n find_pages_and_parts(@layout)\n\n # sends the data in different formats\n respond_to do |format|\n\n if @page.save #page saved successfully\n\n format.html { redirect_to admin_pages_path, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n\n else #page saving failed, re-render the form\n\n format.html { render action: \"new\", :template => 'mcms_pages/admin/pages/new' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n\n end # end if\n\n end # end respond_to block\n\n end",
"def index\n @pages = Page.page params[:page]\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def create\n @admin_page = Admin::Page.new(admin_page_params)\n\n respond_to do |format|\n if @admin_page.save\n format.html { redirect_to edit_admin_page_path(@admin_page), notice: 'Page was successfully created.' }\n format.json { render :show, status: :created, location: @admin_page }\n else\n format.html { render :new }\n format.json { render json: @admin_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(page_params)\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render :show, status: :created, location: @page }\n else\n format.html { render :new }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(page_params)\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render :show, status: :created, location: @page }\n else\n format.html { render :new }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(page_params)\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render :show, status: :created, location: @page }\n else\n format.html { render :new }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n flash[:notice] = 'The page was successfully created.' if page.save\n respond_with(page, location: project_page_path(page.project, page))\n end",
"def index\n @pages = Page.all\n render json: @pages\n end",
"def new\n @root_pages = [fetch_root_page].flatten\n if request.post?\n @page = ComatosePage.new params[:page]\n @page.author = fetch_author_name\n if @page.save\n flash[:notice] = \"Created page '#{@page.title}'\"\n redirect_to :controller=>self.controller_name, :action=>'index'\n end\n else\n @page = ComatosePage.new :title=>'New Page', :parent_id=>(params[:parent] || nil)\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page, :only => [:title, :content] }\n end\n end",
"def create\n @structure_page = Structure::Page.new(params[:structure_page])\n\n respond_to do |format|\n if @structure_page.save\n format.html { redirect_to @structure_page, notice: 'Page was successfully created.' }\n format.json { render json: @structure_page, status: :created, location: @structure_page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @structure_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(page_params)\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render action: 'show', status: :created, location: @page }\n else\n format.html { render action: 'new' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(page_params)\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render action: 'show', status: :created, location: @page }\n else\n format.html { render action: 'new' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\r\n @page = Page.new\r\n respond_to do |format|\r\n format.html # new.html.erb\r\n format.json { render json: @page }\r\n end\r\n end",
"def create\n @page = @parent_page.children.new(params[:page])\n \n @page.site = @site\n @page.created_by = @page.updated_by = current_user\n\n respond_to do |format|\n if @page.save\n flash[:notice] = \"Page was successfully created.\"\n format.html { redirect_to(@parent_page ? admin_site_page_child_path(@site, @parent_page, @page) : admin_site_page_path(@site, @page))}\n format.xml { render :xml => @page, :status => :created, :location => @page }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def index\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def create\n @page = Page.new(pages_params)\n if @page.save\n redirect_to pages_path\n else\n render :new\n end\n end",
"def create\n @page = Page.new(page_params)\n\n respond_to do |format|\n if @page.save\n @pages = current_user.pages\n format.html { redirect_to page_url(@page), notice: \"Page was successfully created.\" }\n format.json { render :show, status: :created, location: @page }\n flash.now[:notice] = \"Page was successfully created.\"\n format.turbo_stream { render \"shared/index\", locals: { object: Page.new, objects: @pages } }\n else\n format.html { render :new, status: :unprocessable_entity }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n @contribution = @page.contributions.build(:user_id => current_user.id)\n @contribution.save\n format.html { redirect_to @page, notice: 'Page was successfully created.' }\n format.json { render json: @page, status: :created, location: @page }\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def index\n\n # find all pages\n @pages = Page.all\n\n # send data in different format\n respond_to do |format|\n format.html{render :template => 'mcms_pages/admin/pages/index'}# index.html.erb\n format.json { render json: @pages }\n end # end respond_to\n\n end",
"def new\n\n @page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end",
"def create\n @page = Page.new(pages_params)\n\n if @page.save\n redirect_to pages_path\n else\n render :new\n end\n end",
"def creates\n @page = Page.new(pages_params)\n\n if @page.sav\n redirect_to pages_path\n else\n render :new\n end\n end",
"def create\n @page = Page.new(page_params)\n respond_to do |format|\n if @page.save\n format.html { redirect_to page_path(@page), notice: 'Page was successfully created.' }\n format.json { render action: 'show', status: :created, location: @page }\n else\n flash[:notice] = @page.errors.full_messages.to_sentence\n format.html { render action: 'new' }\n format.json { render json: [@page.errors.full_messages.to_sentence], status: :unprocessable_entity }\n end\n end\n end",
"def new\n @nested_page = Nested::Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @nested_page }\n end\n end",
"def create\n @page = Page.new(params[:page])\n \n if @page.save\n respond_to do |format|\n format.json { render :json => @page, :status => :created }\n format.xml { render :xml => @page, :status => :created }\n end\n else\n respond_to do |format|\n format.json { raise Palani::Api::InvalidRecordJSONException }\n format.xml { raise Palani::Api::InvalidRecordXMLException }\n end\n end\n end",
"def create\n @page = Page.new(page_params)\n respond_to do |format|\n begin\n if @page.save\n flash[:success] = 'Page was successfully created.'\n format.html { redirect_to admin_page_url(@page) }\n format.json { render :show, status: :created, location: @page }\n else\n format.html { render :new }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n rescue Exception => e \n flash[:danger] = \"Oops! Something went wrong: #{e.message}\"\n format.html { render :new }\n end\n end\n end",
"def new\n @Page = Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @Page }\n end\n end",
"def new\n @page = @user.pages.build\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @page }\n end\n end",
"def create\n @page = @user.pages.build(params[:page])\n\n respond_to do |format|\n if @page.save\n flash[:notice] = 'Page was successfully created.'\n format.html { redirect_to(@page) }\n format.xml { render :xml => @page, :status => :created, :location => @page }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def index\n @pages = current_cms.pages.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @pages }\n end\n end",
"def create\n\t\t@page = Page.new(params[:page])\n\n\t\trespond_to do |format|\n\t\t\tif @page.save\n\t\t\t\tformat.html { redirect_to @page, notice: 'Boom, page created.' }\n\t\t\t\tformat.json { render json: @page, status: :created, location: @page }\n\t\t\telse\n\t\t\t\tformat.html { render action: \"Create new page\"}\n\t\t\t\tformat.json { render json: @page.errors, status: :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def create\n @page_page = PagePage.new(page_page_params)\n\n respond_to do |format|\n if @page_page.save\n format.html { redirect_to @page_page, notice: 'Page page was successfully created.' }\n format.json { render :show, status: :created, location: @page_page }\n else\n format.html { render :new }\n format.json { render json: @page_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def pages\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n # format.html { redirect_to @page, notice: 'Page was successfully created.' }\n # format.json { render json: @page, status: :created, location: @page }\n\n format.html { redirect_to action: \"edit\", id: @page.id, notice: 'Page was successfully created.' }\n format.json { head :no_content }\n\n\n else\n format.html { render action: \"new\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @structure_page = Structure::Page.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @structure_page }\n end\n end",
"def create\n respond_with(@page = Page.create(params[:page]), :status => :created)\n end",
"def new\n @pages_article = PagesArticle.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @pages_article }\n end\n end",
"def create\n @page = Page.new(params[:page])\n flash[:notice] = \"Page successfully created\" if @page.save\n respond_with(@page)\n end",
"def create\n @page = Page.new(params[:page])\n flash[:notice] = \"Page successfully created\" if @page.save\n respond_with(@page)\n end",
"def create\n @page = Page.new(params[:page])\n\n respond_to do |format|\n if @page.save\n format.html { redirect_to admin_pages_path, notice: 'Page bien créée.' }\n else\n format.html { render action: \"new\" }\n end\n end\n end",
"def create\n @page = Static.new(page_params)\n\n if @page.save\n redirect_to admin_pages_path, notice: 'Страница успешно создана!'\n else\n render :new\n end\n end",
"def create\n #@parent_page = Page.find(params[:page][:parent_id])\n \n @page = Page.new(params[:page])\n #@page.move_to_child_of(@parent_page)\n \n respond_to do |wants|\n if @page.save\n flash[:notice] = 'Страница успешно создана.'\n wants.html { redirect_to(admin_pages_url) }\n wants.xml { render :xml => @page, :status => :created, :location => @page }\n else\n wants.html { render :action => \"new\" }\n wants.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def cms_page_params\n params.require(:cms_page).permit(:title, :slug, :content, :cms_layout_id, :parent_id, :description, :hidden, :redirect_url, :draft)\n end",
"def create\n @page = Page.new(page_params)\n\n respond_to do |format|\n if @page.save\n# format.html { redirect_to @page, notice: 'Page was successfully created.' }\n# format.json { render :show, status: :created, location: @page }\n format.html { redirect_to edit_page_path(@page), notice: 'Page was successfully created.' }\n format.json { render :show, status: :created, location: edit_page_path(@page) }\n else\n format.html { render :new }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @pages = Page.new(pages_params)\n if @pages.save\n redirect_to pages_path\n else\n renders :new\n end\nend",
"def publish\n @page.publish\n respond_with(@page, location: published_api_pages_url)\n end",
"def create\n # sleep 2 # Wait for Windows to catch up!\n @page = Page.new(params[:page])\n \n @comic.last_updated = Time.now\n @comic.pages << @page \n \n respond_to do |format|\n if @page.save\n @comic.save\n flash[:notice] = 'Page was successfully created.'\n format.html { redirect_to edit_page_path(:comic_id => @comic.alias, :id => @page) }\n format.xml { head :created, :location => page_url(:comic_id => @comic.alias, :id => @page) }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @page.errors.to_xml }\n end\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def index\n @pages = Page.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pages }\n end\n end",
"def create\n @pages_article = PagesArticle.new(params[:pages_article])\n\n respond_to do |format|\n if @pages_article.save\n format.html { redirect_to @pages_article, notice: 'Pages article was successfully created.' }\n format.json { render json: @pages_article, status: :created, location: @pages_article }\n else\n format.html { render action: \"new\" }\n format.json { render json: @pages_article.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @pageable = polymorphic_parent\n @page = polymorphic_parent.pages.new(params[:page])\n authorize! :create, @page\n\n respond_to do |format|\n if @page.save\n ChalkDust.publish_event(current_user, 'created', @page)\n @activity = ChalkDust::ActivityItem.where(:event => 'created', :target => @page).first\n format.html { redirect_to @page.path, :notice => 'Page was successfully created.' }\n format.json { render :json => @page, :status => :created, :location => @page }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new\n @page = Page.new\n\n respond_to do |format|\n format.json { render json: @page }\n format.xml { render xml: @page }\n end\n end",
"def page_params\n params.require(:page).permit(:title, :slug, :content, :status)\n end",
"def new\n @page = @site.pages.new\n @page.parts << PagePart.new(:name => \"body\")\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @page }\n end\n end",
"def new\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @page }\n end\n end"
] |
[
"0.7243622",
"0.71870834",
"0.71328",
"0.7092713",
"0.70550215",
"0.6958681",
"0.68977296",
"0.6827462",
"0.68213457",
"0.6796138",
"0.67860544",
"0.6785146",
"0.6784767",
"0.67567915",
"0.6750377",
"0.67454386",
"0.6743167",
"0.6719996",
"0.67171437",
"0.6685417",
"0.66588223",
"0.66495067",
"0.66495067",
"0.66495067",
"0.66495067",
"0.66495067",
"0.66495067",
"0.6634786",
"0.6632596",
"0.662343",
"0.6602658",
"0.6587901",
"0.65700835",
"0.65697074",
"0.6562805",
"0.65276974",
"0.65270394",
"0.6524945",
"0.6524945",
"0.6524945",
"0.6523043",
"0.6511596",
"0.65074575",
"0.65032697",
"0.6498804",
"0.64951193",
"0.64951193",
"0.64950216",
"0.64918673",
"0.6476976",
"0.6476976",
"0.6476976",
"0.6476976",
"0.6476976",
"0.64576167",
"0.6450795",
"0.64465386",
"0.6444203",
"0.6441265",
"0.6438354",
"0.6435472",
"0.6431956",
"0.64271826",
"0.640078",
"0.6399683",
"0.6398721",
"0.63977194",
"0.6389055",
"0.63857",
"0.63842356",
"0.6382464",
"0.6381304",
"0.63791674",
"0.6351929",
"0.6344004",
"0.63413155",
"0.63340765",
"0.6329401",
"0.6329401",
"0.63287383",
"0.63280976",
"0.63241947",
"0.6321038",
"0.6320319",
"0.63202506",
"0.63175803",
"0.63130486",
"0.6304505",
"0.6304505",
"0.6304505",
"0.6304505",
"0.6304505",
"0.6304505",
"0.6304505",
"0.6299038",
"0.6277621",
"0.6271346",
"0.6271305",
"0.6268828",
"0.6268603"
] |
0.67217517
|
17
|
PATCH/PUT /cms/pages/1 PATCH/PUT /cms/pages/1.json
|
def update
respond_to do |format|
if @cms_page.update(cms_page_params)
if @cms_page.page_type == "Template"
format.html { redirect_to :action => "add_content", :id => @cms_page.id, notice: 'Page was successfully updated.' }
else
format.html { redirect_to @cms_page, notice: 'Page was successfully updated.' }
end
format.json { render :show, status: :ok, location: @cms_page }
else
format.html { render :edit }
format.json { render json: @cms_page.errors, status: :unprocessable_entity }
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update\n @page = current_cms.pages.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:big_cms_page])\n format.html { render :action => \"edit\" }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @cms_page.update(cms_page_params)\n format.html { redirect_to @cms_page, notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @cms_page }\n else\n format.html { render :edit }\n format.json { render json: @cms_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @cms_page.update(cms_page_params)\n format.html { redirect_to @cms_page, notice: 'Cms page was successfully updated.' }\n format.json { render :show, status: :ok, location: @cms_page }\n else\n format.html { render :edit }\n format.json { render json: @cms_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.json { head :no_content }\n format.xml { head :no_content }\n else\n format.json { render json: @page.errors, status: :unprocessable_entity }\n format.xml { render xml: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to admin_subject_pages_path, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if page_params[:body]\n @page.versions << Version.new(body: page_params[:body], title: page_params[:title]).save\n page_params.delete :body\n end\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to controller: \"pages\", action: \"show\", slug: @page[:page_slug], notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @cms_page = CmsPage.find(params[:id])\n params[:cms_page][:parent_id] = 0 if params[:cms_page][:parent_id].blank?\n respond_to do |format|\n if @cms_page.update_attributes(params[:cms_page])\n expire_page \"/#{@cms_page.path}\"\n flash[:notice] = 'CMS Page was successfully updated.'\n format.html { redirect_to(['admin', @cms_page]) }\n format.xml { head :ok }\n else\n\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @cms_page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to pages_path, sucess: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = current_site.pages.find(params[:id])\n @site = @page.site\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to(@page, :notice => 'Page was successfully updated.') }\n format.json { respond_with_bip(@page) }\n else\n format.html { render :action => \"edit\" }\n format.json { respond_with_bip(@page) }\n end\n end\n end",
"def update\n @page = Page.find(params[:page][:id])\n if current_user.id != @page.owner_id\n not_found\n end\n @page.partial_update(params)\n respond_to do |format|\n format.json {\n render partial: 'pages/page.json'\n }\n end\n end",
"def update\n authorize @page_content.page, :update?\n\n respond_to do |format|\n if @page_content.update(page_content_params)\n format.json { render :show, status: :ok, location: @page_content }\n else\n format.json { render json: @page_content.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = ContentPage.find(params[:id])\n respond_to do |format|\n if @page.update_attributes(params[:content_page])\n @editingPage = false\n format.html { redirect_to show_content_pages_path(@page.id), notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { redirect_to edit_content_pages_path(@page.id), alert: 'Unable to update Page successfully.'}\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to pages_path, notice: 'Page was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n #Render the object created or errors\n respond_to do |format|\n if @page.update(page_params)\n #Cache bust pages and updated page. With pagination we would only bust the cache of the page that was updated.\n Rails.cache.delete(\"pages\")\n Rails.cache.delete(\"page-#{@page.id}\")\n format.json { render action: 'show', status: :ok, location: api_page_url(@page) }\n else\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @cms_page_section.update(cms_page_section_params)\n format.html { redirect_to @cms_page_section, notice: 'Page section was successfully updated.' }\n format.json { render :show, status: :ok, location: @cms_page_section }\n else\n format.html { render :edit }\n format.json { render json: @cms_page_section.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to page_path(@page), notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @nested_page = Nested::Page.find(params[:id])\n\n respond_to do |format|\n if @nested_page.update_attributes(params[:nested_page])\n format.html { redirect_to @nested_page, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @nested_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = current_site.pages.find_by_permalink(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to quick_page_path(@page), notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n format.js\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n format.js\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to [:admin, @page], notice: 'Страница успешно создана.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n #find the page with given id\n @page = Page.find(params[:id])\n\n #use updated_at manually, it will update the page table if user hits update button.\n # This may not be trivial, so it may change.\n @page.updated_at = Time.now\n\n #retrieving layout id from params and assigning to a variable\n @layout = @page[:layout_id]\n\n # calling method to find all pages and page parts\n find_pages_and_parts(@layout)\n\n #sends in data in different format\n respond_to do |format|\n\n if @page.update_attributes(params[:page]) #page updated successfully\n\n format.html { redirect_to admin_pages_path, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n\n else #page saving failed, re-renders edit template\n\n format.html { render action: \"edit\", :template => 'mcms_pages/admin/pages/edit' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n\n end # end if\n\n end # end respond_to block\n\n end",
"def update\n @page = Page.find(params[:id])\n @page.section_id = params[:section_id] unless params[:section_id].nil? \n @page.title = params[:title] unless params[:title].nil? \n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n #ormat.json { head :no_content }\n format.js\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @structure_page = Structure::Page.find(params[:id])\n\n respond_to do |format|\n if @structure_page.update_attributes(params[:structure_page])\n format.html { redirect_to @structure_page, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @structure_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n @page.update_attributes(params[:page])\n respond_with(@page)\n end",
"def update\n @page = Page.find_by_slug(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n @page.update_attribute('published_at', Time.now) if params[:commit] == 'Publish'\n @page.update_attribute('published_at', nil) if params[:commit] == 'Unpublish'\n \n if params[:commit] == 'Publish'\n format.html { redirect_to root_page_path(@page), notice: 'Page was successfully published.' }\n else\n format.html { redirect_to edit_page_path(@page), notice: 'Page was successfully updated.' }\n end\n \n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n @page.update_attributes(params[:page])\n respond_with(@page, :status => :updated)\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n # format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.html { redirect_to action: \"edit\", id: params[:id], notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.friendly.find(params[:id])\n\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to [:admin, @page], notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n if @page.update_attributes(params[:page])\n respond_to do |format|\n format.json {render json: @page, status: :created }\n format.xml {render xml: @page, status: :created}\n end\n \n else\n respond_to do |format|\n format.json {render json: @page.errors, status: :unprocessable_entity}\n format.xml {render xml: @page.errors, status: :unprocessable_entity}\n end\n end\n end",
"def update\n expire_page :action => :show\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n # Clear the page cache for this page... ?\n @page = ComatosePage.find params[:id]\n @root_pages = [fetch_root_page].flatten\n if request.post?\n @page.update_attributes(params[:page])\n @page.updated_on = Time.now\n @page.author = fetch_author_name\n if @page.save\n expire_cms_page @page\n expire_cms_fragment @page\n flash[:notice] = \"Saved changes to '#{@page.title}'\"\n redirect_to :controller=>self.controller_name, :action=>'index'\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to @page, notice: \"Page was successfully updated. #{undo_link}\" }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to @pages_tree[(@page.id).to_s], notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n @testimonials = Testimonial.all\n \n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to all_pages_path(:magazine_id=>@page.magazine_id), notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n \n Rails.logger.info \"ID: #{params[:id]}\"\n Rails.logger.info \"BODY: #{params[:page][:body].inspect}\"\n\n # Convert <div> line breaks to <p>\n params[:page][:body] = params[:page][:body].gsub(/\\<div\\>/, '<p>')\n params[:page][:body] = params[:page][:body].gsub(/\\<\\/div\\>/, '</p>')\n params[:page][:body] = params[:page][:body].gsub(/\\<p\\>\\<br\\>\\<\\/p\\>/, '')\n params[:page][:body] = params[:page][:body].gsub(/\\<br\\>/, '')\n \n respond_to do |format|\n if @page.update_attributes(params[:page])\n Rails.logger.info \"UPDATED PAGE!\"\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { render :json => @page }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n # @page = Page.new(page_params)\n\n # @page.components.build\n # @page.update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = current_user.pages.find(params[:id])\n \n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to page_path(@page) }\n else\n format.html { render action: \"edit\" }\n end\n end\n end",
"def update\n if @page.update_attributes(params[:page])\n respond_with(@page)\n else\n respond_with(@page)\n end\n end",
"def update\n @sync_page = SyncPage.find(params[:id])\n\n respond_to do |format|\n if @sync_page.update_attributes(params[:sync_page])\n format.html { redirect_to @sync_page, notice: 'Sync page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @sync_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @pages_article = PagesArticle.find(params[:id])\n\n respond_to do |format|\n if @pages_article.update_attributes(params[:pages_article])\n format.html { redirect_to @pages_article, notice: 'Pages article was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @pages_article.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\r\n @page = Page.find(params[:id])\r\n respond_to do |format|\r\n if @page.update_attributes(params[:page])\r\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\r\n format.json { head :no_content }\r\n target = \"#{Rails.public_path}/#{@page.project_id}/#{@page.page_name}.html\"\r\n File.open(target, \"w\") do |f|\r\n f.write(@page.html)\r\n end\r\n else\r\n format.html { render action: \"edit\" }\r\n format.json { render json: @page.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to admin_pages_path, notice: 'Page bien modifiée.' }\n else\n format.html { render action: \"edit\" }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to page_path(@page), notice: 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n flash[:notice] = @page.errors.full_messages.to_sentence\n format.html { render action: 'edit' }\n format.json { render json: [@page.errors.full_messages.to_sentence], status: :unprocessable_entity }\n end\n end\n end",
"def update\n @pages_feature = Page.where(site_id: @site.id, published: true, feature_on_homepage: true).all\n @page_root = Page.where(site_id: @site.id).roots.all\n @title = @page.title\n respond_to do |format|\n session[:return_to] ||= request.referer\n if @page.update(page_params)\n format.html { redirect_to session.delete(:return_to), notice: 'Saved' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to(pages_path, :notice => 'Page was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(admin_page_params)\n format.html { redirect_to admin_pages_url, notice: 'page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |wants|\n if @page.update_attributes(params[:page])\n \n flash[:notice] = 'Страница сохранена.'\n wants.html { redirect_to(admin_pages_url) }\n wants.xml { head :ok }\n else\n wants.html { render :action => \"edit\" }\n wants.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = @site.pages.find(params[:id])\n @page.updated_by = current_user\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = \"Page was successfully updated.\"\n format.html { redirect_to(@parent_page ? admin_site_page_child_path(@site, @parent_page, @page) : admin_site_page_path(@site, @page)) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @oasis_page = OasisPage.find(params[:id])\n\n respond_to do |format|\n if @oasis_page.update_attributes(params[:oasis_page])\n format.html { redirect_to @oasis_page, notice: 'Oasis page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @oasis_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update \n # looking for a page with a specific id \n @pages = Page.find(params[:id])\n\n # updates with new information\n if @page.update(pages_params)\n redirect_to pages_path\n else \n render :edit \n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n restrict('allow only admins') or begin\n @page = Page.find_by_stub(params[:stub]) || Page.find_by_id(params[:id])\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = 'Page was successfully updated.'\n format.html { redirect_to manage_pages_path }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors.to_xml }\n end\n end\n end\n end",
"def update\n @page = Page.find_by_slug(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = 'Page was successfully updated.'\n format.html { redirect_to @page.get_page_path }\n # format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = @club.pages.find(params[:id])\n @page.parent_id = params[:page][:parent_id];\n @page.bns_parent_id = params[:page][:parent_id];\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = 'Pages was successfully updated.'\n format.html { redirect_to(admin_club_page_path(@club, @page)) }\n format.xml { head :ok }\n else\n @pagelist = @club.all_pages\n @pagelist = @club.all_pages\n @pagelist -= @page.all_children << @page\n \n @page_title = \"Editing \" + @page.title\n @site_section = \"admin\"\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @pageable = polymorphic_parent\n @page = polymorphic_parent.pages.find(params[:id])\n authorize! :update, @page\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to @page.path, :notice => 'Page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = 'Pages was successfully updated.'\n format.html { redirect_to(@page) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @section = Section.find(params[:id])\n @page = @section.page\n\n respond_to do |format|\n if @section.update_attributes(params[:section])\n format.html { redirect_to @page, :notice => 'Section was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @section.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def edit\n @page = Page.find(params[:id])\n\n respond_to do |format|\n format.json {render json: @page}\n format.xml {render xml: @page}\n end\n end",
"def update\n respond_to do |format|\n if @extra_page.update(extra_pages_params)\n format.html { redirect_to @extra_page, notice: 'Your Extra Pages were successfully updated.' }\n format.json { render :show, status: :ok, location: @extra_page }\n else\n format.html { render :edit }\n format.json { render json: @extra_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\t\t@page = Page.find(params[:id])\n\n\t\trespond_to do |format|\n\t\t\tif @page.update_attributes(params[:page])\n\t\t\t\tformat.html { redirect_to @page, notice: 'Boom, page updated.' }\n\t\t\t\tformat.json { head :no_content }\n\t\t\telse\n\t\t\t\tformat.html { render action: \"edit\" }\n\t\t\t\tformat.json { render json: @post.errors, status: :unprocessable_entity }\n\t\t\tend\n\t\tend\n\tend",
"def update\n @page = Page.find(params[:id])\n\n # Update the last user that updated the content\n @page.content.user = current_user if logged_in?\n @page.content.published = true if params[:commit] == \"Publish\"\n @page.tag_list.add(params[:tags_to_apply], :parse => true)\n\t\n respond_to do |format|\n if @page.update_attributes(params[:page]) && @page.content.update_attributes(params[:content])\n notify :notice, 'Page was successfully updated.'\n \n format.html { redirect_to(@page) }\n format.xml { head :ok }\n format.js\n else\n\t\t notify :error, \"There was an error updating the page.\"\n\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n if @page.update(pages_params)\n redirect_to pages_path\n else\n render :edit\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = t(:page_updated)\n format.html { redirect_back_or_default(admin_page_path(@page)) }\n format.xml { head :ok }\n else\n format.html { render :action => 'edit' }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to(@page, :notice => 'Page was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to(@page, :notice => 'Page was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n authorize! :update, @page\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to @page, notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @test_page = TestPage.find(params[:id])\n\n respond_to do |format|\n if @test_page.update_attributes(params[:test_page])\n format.html { redirect_to @test_page, notice: 'Test page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @test_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(update_page_params)\n format.html {}\n format.json {}\n\n render \"show\"\n else\n format.html { render \"show\", status: :not_acceptable }\n format.json { render json: @page.errors, status: :not_acceptable }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page_page.update(page_page_params)\n format.html { redirect_to @page_page, notice: 'Page page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page_page }\n else\n format.html { render :edit }\n format.json { render json: @page_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @mypage = Mypage.find(params[:id])\n\n respond_to do |format|\n if @mypage.update_attributes(params[:mypage])\n format.html { redirect_to @mypage, notice: 'Mypage was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @mypage.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if @page.update_attributes(params[:page])\n respond_to do |format|\n format.json { render :json => @page }\n format.xml { render :xml => @page }\n end\n else\n respond_to do |format|\n format.json { raise Palani::Api::InvalidUpdateOfRecordJSONException }\n format.xml { raise Palani::Api::InvalidUpdateOfRecordXMLException }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n Rails.application.reload_routes!\n format.html { redirect_to admin_page_path(@page), notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n # log\n fields = @page.fields.each do |f| f.inspect end\n register_log \"Page updated: #{@page.inspect} -- Custom type fields: #{fields}\\n\"\n end",
"def update\n @document_page = DocumentPage.find(params[:id])\n\n respond_to do |format|\n if @document_page.update_attributes(params[:document_page])\n format.html { redirect_to @document_page, notice: 'Document page was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @document_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n flash[:notice] = 'The page was successfully updated.' if page.update_attributes(params[:page])\n respond_with(page, location: project_page_path(page.project, page))\n end",
"def update\n @pagecontent = @page.pagecontents.find(params[:id])\n\n respond_to do |format|\n if @pagecontent.update_attributes(params[:pagecontent])\n flash[:notice] = 'Pagecontent was successfully updated.'\n format.html {redirect_to(page_pagecontents_path(@page)) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @pagecontent.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n @pages = current_user.pages\n format.html { redirect_to page_url(@page), notice: \"Page was successfully updated.\" }\n format.json { render :show, status: :ok, location: @page }\n flash.now[:notice] = \"Page was successfully updated.\"\n format.turbo_stream { render \"shared/update\", locals: { object: @page, short: @short } }\n\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page_chunk = PageChunk.find(params[:id])\n #TODO: Not sure why \"undefined\" is a key.\n #TODO: multiple editable section on one page not working; the content for the last\n # is always \n @page_chunk.content = params[:content][:undefined][:value]\n @page_chunk.save!\n\n render text: \"\"\n=begin\n respond_to do |format|\n if @page_chunk.update(page_chunk_params)\n format.html { redirect_to @page_chunk, notice: 'Page chunk was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @page_chunk.errors, status: :unprocessable_entity }\n end\n end\n=end\n end",
"def update\n\n respond_to do |format|\n if @page_object.update_attributes(params[:page_object])\n flash[:notice] = 'PageObject was successfully updated.'\n format.html { redirect_to(@page_object) }\n format.xml { head :ok }\n format.tson { head :ok }\n else\n render_to_page_object\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page_object, :status => :unprocessable_entity }\n format.tson { render :json => @page_object, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n begin\n if @page.update(page_params)\n flash[:success] = 'Page was successfully updated.'\n format.html { redirect_to admin_page_url(@page) }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n rescue Exception => e \n flash[:danger] = \"Oops! Something went wrong: #{e.message}\"\n format.html { render :new }\n end\n end\n end",
"def update\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to edit_admin_page_path(@page), notice: 'Page was successfully updated.' }\n else\n format.html { render :edit }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n if @page .update(pages_params)\n redirect_to pages_path\n else\n render :edit\n end\n end",
"def update\n authorize @page\n respond_to do |format|\n if @page.update(page_params)\n format.html { redirect_to edit_page_path(@page), notice: 'Page was successfully updated.' }\n format.json { render :show, status: :ok, location: @page }\n else\n format.html { render :edit }\n format.json { render json: @page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n\n # find page with given ID\n #@page = Page.find(params[:id])\n @page = Page.find_by_slug_or_id(params[:path], params[:id])\n\n if @page.nil?\n\n raise ActiveRecord::RecordNotFound\n\n else\n\n #retrieving layout id from params and assigning to a variable\n @layout = @page[\"layout_id\"]\n\n end # end if\n\n # calling method to find all pages and page parts\n find_pages_and_parts(@layout)\n\n #sends data in different formats\n respond_to do |format|\n\n format.html{render :template => 'mcms_pages/admin/pages/edit'}# edit.html.erb\n format.json { render json: @page }\n\n end # end respond_to block\n\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = 'Page was successfully updated.'\n format.html { redirect_to(@page) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = 'Page was successfully updated.'\n format.html { redirect_to(@page) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n @user = current_user\n respond_to do |format|\n if @page.update_attributes(params[:page])\n format.html { redirect_to(@page, :notice => 'Page was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = :page_updated.l\n format.html { redirect_to(@page) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @about_page = AboutPage.find(params[:id])\n\n respond_to do |format|\n if @about_page.update_attributes(params[:about_page])\n format.html { redirect_to @about_page, notice: 'About page was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @about_page.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @page = Page.find(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = 'Siden ble oppdatert.'\n format.html { redirect_to(@page) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @page = @user.pages.find_by_permalink(params[:id])\n\n respond_to do |format|\n if @page.update_attributes(params[:page])\n flash[:notice] = 'Page was successfully updated.'\n format.html { redirect_to(@page) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @page.errors, :status => :unprocessable_entity }\n end\n end\n end"
] |
[
"0.71848303",
"0.69642866",
"0.69482815",
"0.68609107",
"0.67964363",
"0.679205",
"0.6771985",
"0.6746097",
"0.67242384",
"0.67217857",
"0.6716855",
"0.6683872",
"0.66713697",
"0.6643328",
"0.6638371",
"0.6638371",
"0.66383207",
"0.66339535",
"0.6623543",
"0.66084224",
"0.66084224",
"0.6591041",
"0.65842843",
"0.65511984",
"0.65487874",
"0.6546901",
"0.65243316",
"0.6506676",
"0.6496907",
"0.64931166",
"0.64931166",
"0.64908934",
"0.64884204",
"0.64868766",
"0.6482076",
"0.6470939",
"0.6464827",
"0.6461365",
"0.64592475",
"0.6437061",
"0.6421933",
"0.64079237",
"0.6388618",
"0.638806",
"0.6387608",
"0.6366475",
"0.6365608",
"0.63624686",
"0.63550293",
"0.6342833",
"0.6287469",
"0.62826663",
"0.62673575",
"0.62661755",
"0.62511903",
"0.6249184",
"0.6246523",
"0.6245004",
"0.6245004",
"0.6245004",
"0.6245004",
"0.6231444",
"0.62205267",
"0.61949104",
"0.61880267",
"0.61868626",
"0.6182234",
"0.61801857",
"0.61781013",
"0.61740535",
"0.61739814",
"0.61702436",
"0.61567205",
"0.6155756",
"0.6155756",
"0.6149411",
"0.6148638",
"0.61432004",
"0.6141292",
"0.6133623",
"0.6129238",
"0.6122044",
"0.6120928",
"0.61146814",
"0.61119473",
"0.6110973",
"0.60890853",
"0.6087961",
"0.6087768",
"0.60804945",
"0.60747963",
"0.60707223",
"0.60632753",
"0.60508263",
"0.60508263",
"0.60240966",
"0.6023691",
"0.60193115",
"0.60167986",
"0.6011441"
] |
0.6748274
|
7
|
DELETE /cms/pages/1 DELETE /cms/pages/1.json
|
def destroy
@cms_page.destroy
respond_to do |format|
format.html { redirect_to cms_pages_url, notice: 'Page was successfully destroyed.' }
format.json { head :no_content }
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def destroy\n @cms_page.destroy\n respond_to do |format|\n format.html { redirect_to cms_pages_url, notice: \"#{@cms_page.title} has been deleted.\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cms_page.destroy\n respond_to do |format|\n format.html { redirect_to cms_pages_url, notice: 'Cms page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = current_cms.pages.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(big_cms_pages_url) }\n format.xml { head :ok }\n end\n end",
"def delete_page(id)\n @client.raw('delete', \"/content/pages/#{id}\")\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = current_site.pages.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to edit_site_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @cms_page = CmsPage.find(params[:id])\n @cms_page.destroy\n\n respond_to do |format|\n format.html { redirect_to(admin_cms_pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @cms_page_section.destroy\n respond_to do |format|\n format.html { redirect_to cms_page_sections_url, notice: 'Page section was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @structure_page = Structure::Page.find(params[:id])\n @structure_page.destroy\n\n respond_to do |format|\n format.html { redirect_to structure_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.friendly.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :ok }\n end\n end",
"def destroy\r\n @page = Page.find(params[:id])\r\n @page.destroy\r\n File.delete(\"#{Rails.public_path}/#{@page.project_id}/#{@page.page_name}.html\")\r\n respond_to do |format|\r\n format.html { redirect_to pages_url }\r\n format.json { head :no_content }\r\n end\r\n end",
"def destroy\n @page = Page.find_by_slug(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to root_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.json { head :no_content }\n format.xml { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to root_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @static_page = StaticPage.find(params[:id])\n @static_page.destroy\n\n respond_to do |format|\n format.html { redirect_to static_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @static_page = StaticPage.find(params[:id])\n @static_page.destroy\n\n respond_to do |format|\n format.html { redirect_to static_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to admin_pages_url, notice: 'Страница успешно удалена!' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url, :notice => \"Successfully deleted page. #{undo_link}\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @static_page = StaticPage.find(params[:id])\n @static_page.destroy\n\n respond_to do |format|\n format.html { redirect_to static_pages_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n head :no_content\n end",
"def delete\n @page = ComatosePage.find params[:id]\n if request.post?\n expire_cms_pages_from_bottom @page\n expire_cms_fragments_from_bottom @page\n @page.destroy\n flash[:notice] = \"Deleted page '#{@page.title}'\"\n redirect_to :controller=>self.controller_name, :action=>'index'\n end\n end",
"def destroy\n @nested_page = Nested::Page.find(params[:id])\n @nested_page.destroy\n\n respond_to do |format|\n format.html { redirect_to nested_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mypage = Mypage.find(params[:id])\n @mypage.destroy\n\n respond_to do |format|\n format.html { redirect_to mypages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @oasis_page = OasisPage.find(params[:id])\n @oasis_page.destroy\n\n respond_to do |format|\n format.html { redirect_to oasis_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @sync_page = SyncPage.find(params[:id])\n @sync_page.destroy\n\n respond_to do |format|\n format.html { redirect_to sync_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admin_page = Page.find(params[:id])\n @admin_page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n end\n end",
"def destroy\n @admin_page.destroy\n respond_to do |format|\n format.html { redirect_to admin_pages_url, notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.json { render :json => @page }\n format.xml { render :xml => @page }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to all_pages_path(:magazine_id=>@page.magazine_id), notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @rcadmin_static_page.destroy\n respond_to do |format|\n flash[:notice] = 'Static page was successfully deleted.'\n format.html { redirect_to rcadmin_static_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url, notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url, notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url, notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url, notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url, notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url, notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url, notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_url, notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @comic_page = ComicPage.find(params[:id])\n @comic_page.destroy\n\n respond_to do |format|\n format.html { redirect_to comic_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @about_page = AboutPage.find(params[:id])\n @about_page.destroy\n\n respond_to do |format|\n format.html { redirect_to about_pages_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @page = current_site.pages.find_by_permalink(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_url }\n format.json { head :no_content }\n format.js\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to(admin_pages_url) }\n format.xml { head :ok }\n end\n website.add_log(user: current_user, action: \"Deleted page: #{@page.title}\")\n end",
"def destroy\n\n # find the page with with\n @page = Page.find(params[:id])\n\n # calling class method of PagePart model to delete page parts of a page\n PagePart.delete_page_parts(@page)\n\n #destroy the page\n @page.destroy\n\n #sends in data in different format to index action\n respond_to do |format|\n\n format.html { redirect_to admin_pages_url }\n format.json { head :no_content }\n\n end # end respond_to block\n\n end",
"def destroy\n @test_page = TestPage.find(params[:id])\n @test_page.destroy\n\n respond_to do |format|\n format.html { redirect_to test_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @pages_article = PagesArticle.find(params[:id])\n @pages_article.destroy\n\n respond_to do |format|\n format.html { redirect_to pages_articles_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = @site.pages.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(@parent_page ? admin_site_page_children_url(@site, @parent_page) : admin_site_pages_url(@site)) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page.destroy\n\n respond_to do |wants|\n wants.html { redirect_to(admin_pages_url) }\n wants.xml { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_pages_path }\n end\n end",
"def delete_page(page)\n transaction \"delete `#{page.title}'\" do\n store.delete(page.title + '.md')\n end\n end",
"def destroy\n @page = Page.find_by_slug(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page_page.destroy\n respond_to do |format|\n format.html { redirect_to page_pages_url, notice: 'Page page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @admined_page1 = AdminedPage1.find(params[:id])\n @admined_page1.destroy\n\n respond_to do |format|\n format.html { redirect_to admined_page1s_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to pages_path(page: params[:page], type: params[:type]) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n respond_with(@page, :status => :deleted, :location => pages_path)\n end",
"def destroy\n @content_page = ContentPage.find(params[:id])\n @content_page.destroy\n\n respond_to do |format|\n format.html { redirect_to(content_pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @page = @user.pages.find_by_permalink(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @pages_dynamic_page = Pages::DynamicPage.find(params[:id])\n @pages_dynamic_page.destroy\n\n respond_to do |format|\n format.html { redirect_to(pages_dynamic_pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n Page.find(params[:id]).destroy\n redirect_to pages_path\n end",
"def destroy\n @page.destroy\n respond_to do |format|\n format.html { redirect_to admin_pages_url, notice: 'Page was successfully destroyed.' }\n end\n end",
"def destroy\n @story_page.destroy\n respond_to do |format|\n format.html { redirect_to story_pages_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @section = Section.find(params[:id])\n @page = @section.page\n @section.destroy\n\n respond_to do |format|\n format.html { redirect_to @page, :notice => 'Section was successfully deleted.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(page_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @static_page = StaticPage.find(params[:id])\n @static_page.destroy\n\n respond_to do |format|\n format.html { redirect_to(static_pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy \n @page.destroy\n respond_to do |format|\n format.html { redirect_to website_path(params[:website_id]), notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page = @club.pages.find(params[:id])\n\t\t#destroy settings\n\t\t@settings = @club.settings.find(:all, :conditions => ['name = ? AND value = ?', 'pages', @page.id]);\n\t\t@settings.each do |setting|\n\t\t\tsetting.destroy\n\t\tend\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to(admin_club_pages_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @info_page = InfoPage.find(params[:id])\n @info_page.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_info_pages_path }\n format.json { head :no_content }\n end\n end",
"def destroy\n # Trying to delete a page that is homepage\n if(Setting.where(key: \"homepage\").first.value == \"/pages/\" + @page.id.to_s)\n redirect_to admin_settings_path, alert: \"You are trying to delete a page that is Homepage. \n Please change the settings first.\"\n else\n # var for register_log\n fields = @page.fields.each do |f| f.inspect end\n\n @page.destroy\n respond_to do |format|\n format.html { redirect_to admin_pages_url, notice: 'Page was successfully destroyed.' }\n format.json { head :no_content }\n end\n # log\n register_log \"Page destroyed: #{@page.inspect} -- Custom type fields: #{fields}\\n\"\n end\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect }\n format.xml { head :ok }\n end\n end",
"def destroy\n @pagecontent = @page.pagecontents.find(params[:id])\n @pagecontent.destroy\n\n respond_to do |format|\n format.html { redirect_to(page_pagecontents_path(@page)) }\n format.xml { head :ok }\n end\n end",
"def destroy\n #@static_content = StaticContent.find(params[:id])\n #@static_content.destroy\n #\n #respond_to do |format|\n # format.html { redirect_to static_contents_url }\n # format.json { head :no_content }\n #end\n end",
"def destroy\n @dynamic_project_page.destroy\n respond_to do |format|\n format.html { redirect_to '/administrator/dynamic_project_pages', notice: 'Информация обновлена' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @page.delete\n @message = {message: 'Page deleted'}\n respond_with(@message)\n end",
"def destroy\n @page = @chapter.pages.find_by_number(params[:id])\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to manga_chapter_url(@manga, @chapter) }\n format.json { head :no_content }\n end\n end",
"def destroy \n # finds and delete page \n Page.find(params[:id]).destroy\n # take us back to all pages \n redirect_to pages_path\n end",
"def destroy\n @page = Page.find(params[:id])\n @page.destroy\n respond_with(@page)\n end",
"def destroy\n @contentperpage.destroy\n respond_to do |format|\n format.html { redirect_to contentperpages_url, notice: 'Contentperpage was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @subject = Subject.find(params[:subject_id])\n # Need to delete pageable too?\n @pageable = @page.pageable\n @pageable.destroy\n @page.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_subject_pages_path(@subject) }\n format.json { head :no_content }\n end\n end"
] |
[
"0.78697467",
"0.7766718",
"0.7704622",
"0.76399887",
"0.7600261",
"0.7593965",
"0.75675017",
"0.74696565",
"0.7417237",
"0.7417237",
"0.7417237",
"0.7417237",
"0.73983175",
"0.738937",
"0.73876965",
"0.73876965",
"0.73876965",
"0.73876965",
"0.73876965",
"0.73876965",
"0.73876965",
"0.73876965",
"0.7374864",
"0.7374864",
"0.7374864",
"0.73062366",
"0.7300098",
"0.72998345",
"0.7270684",
"0.72687674",
"0.72687674",
"0.72672826",
"0.7265086",
"0.7259624",
"0.72289664",
"0.7204254",
"0.7201578",
"0.7195605",
"0.71882206",
"0.7187984",
"0.71586126",
"0.7153371",
"0.71523345",
"0.7139737",
"0.71333456",
"0.7125825",
"0.7125825",
"0.7125825",
"0.7125825",
"0.7125825",
"0.7125825",
"0.7125825",
"0.7125825",
"0.71250415",
"0.711932",
"0.71171695",
"0.7114087",
"0.71136063",
"0.7103434",
"0.7101044",
"0.70900506",
"0.70869076",
"0.70848525",
"0.7081942",
"0.7077228",
"0.70642525",
"0.70642525",
"0.70642525",
"0.70642525",
"0.70642525",
"0.70642525",
"0.70642525",
"0.70642525",
"0.7055098",
"0.7043566",
"0.7039235",
"0.7013502",
"0.69999284",
"0.6984284",
"0.6964924",
"0.6964402",
"0.69378877",
"0.69264644",
"0.6925321",
"0.69226104",
"0.6920794",
"0.69134647",
"0.69129264",
"0.69102937",
"0.69022787",
"0.6901246",
"0.6893426",
"0.6880834",
"0.68771064",
"0.68770427",
"0.6857374",
"0.6853109",
"0.68482035",
"0.6836155",
"0.6835924"
] |
0.77656174
|
2
|
Use callbacks to share common setup or constraints between actions.
|
def set_cms_page
@cms_page = Cms::Page.friendly.find(params[:id])
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def setup_handler\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def workflow\n end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup\n # override and do something appropriate\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def before_action \n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def setup_signals; end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def initialize(*args)\n super\n @action = :set\nend",
"def after_set_callback; end",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def around_hooks; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def duas1(action)\n action.call\n action.call\nend",
"def shared_action(name, &block)\n @controller.shared_actions[name] = block\n end",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] |
[
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576",
"0.53124547",
"0.529654",
"0.5296262",
"0.52952296",
"0.52600986",
"0.52442724",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.5232394",
"0.523231",
"0.5227454",
"0.52226824",
"0.52201617",
"0.5212327",
"0.52079266",
"0.52050185",
"0.51754695",
"0.51726824",
"0.51710224",
"0.5166172",
"0.5159343",
"0.51578903",
"0.51522785",
"0.5152022",
"0.51518047",
"0.51456624",
"0.51398855",
"0.5133759",
"0.5112076",
"0.5111866",
"0.5111866",
"0.5110294",
"0.5106169",
"0.509231",
"0.50873137",
"0.5081088",
"0.508059",
"0.50677156",
"0.50562143",
"0.5050554",
"0.50474834",
"0.50474834",
"0.5036181",
"0.5026331",
"0.5022976",
"0.5015441",
"0.50121695",
"0.5000944",
"0.5000019",
"0.4996878",
"0.4989888",
"0.4989888",
"0.49864885",
"0.49797225",
"0.49785787",
"0.4976161",
"0.49683493",
"0.4965126",
"0.4958034",
"0.49559742",
"0.4954353",
"0.49535993",
"0.4952725",
"0.49467874",
"0.49423352",
"0.49325448",
"0.49282882",
"0.49269363",
"0.49269104",
"0.49252945",
"0.4923091",
"0.49194667",
"0.49174926",
"0.49173003",
"0.49171105",
"0.4915879",
"0.49155936"
] |
0.0
|
-1
|
Never trust parameters from the scary internet, only allow the white list through.
|
def cms_page_params
params.require(:cms_page).permit(:title, :category, :page_type, :external_url, :internal_url, :document, :page_template_id, :cols, page_sections_attributes: [ :id, :photo, :body, :page_id ])
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def param_whitelist\n [:role, :title]\n end",
"def expected_permitted_parameter_names; end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def allowed_params\n params.require(:user).permit(:username, :email, :password, :password_confirmation)\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def user_params \n \tparams.require(:user).permit(:name, :email, :password, :password_confirmation)# preventing CSTR\n end",
"def user_params\n params.permit(:name, :phoneNumber, :address, :postalCode, :local, :link, :counter, :latitude, :longitude) \n end",
"def valid_params_request?; end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def whitelist_url_params\n params.require(:whitelist_url).permit(:domain)\n end",
"def allowed_params\n params.require(:allowed).permit(:email)\n end",
"def permitted_params\n []\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def query_param\n\t\tparams.permit(:first_name, :last_name, :phone)\n\tend",
"def strong_params\n params.require(:success_metric).permit(param_whitelist)\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def whitelisted_user_params\n params.require(:user).\n permit( :first_name, :last_name, :email,:password,:password_confirmation,:birthday,:gender)\n end",
"def user_params\n ActionController::Parameters.permit_all_parameters = true\n params.require(:user) #.permit(:name, :surname, :phone, :password, :email, :time_zone)\n end",
"def strong_params\n params.require(:metric_change).permit(param_whitelist)\n end",
"def safe_params\n params.require(:user).permit(:name)\n end",
"def get_params\n\t\treturn ActionController::Parameters.new(self.attributes).permit(\"account_id\", \"title\", \"category\", \"introduction\", \"tags\", \"segment_type\", \"visible\", \"status\", \"main_image\")\n\tend",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def check_params; true; end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def quote_params\n params.permit!\n end",
"def valid_params?; end",
"def paramunold_params\n params.require(:paramunold).permit!\n end",
"def user_params\n\t\tparams.permit(:nickname, :avatar, :description, :password, :gender, :birthday, :email, :phone, :qq_id, :wechat_id)\n\tend",
"def filtered_parameters; end",
"def user_params\n params.permit(\n \t:id,\n \t:email, \n \t:first_name, \n \t:last_name, \n \t:password, \n \t:confirm_token, \n \t:phone_number,\n \t:facebook_link,\n \t:car_model,\n \t:license_plate)\n end",
"def filtering_params\n params.permit(:email, :name)\n end",
"def check_params\n true\n end",
"def wx_public_params\n params.require(:wx_public).permit(:nickname, :manager, :alias)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def listing_params\n\t\tparams.permit(:address, :transit_info, :rules, :other_info, :lat, :lng)\n\tend",
"def social_account_params\n\t\t\tparams.require(:social_account).permit!\n\t\tend",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def url_params\n params.require(:url).permit(:short_url, :original_url, :clicks, :ip_addresses)\n end",
"def user_params\n params.require(:user).permit(:uri, :username, :password, :realname, :email, :publicvisible)\n end",
"def model_params\n\t\tparams.require(:manager).permit(\n\t :user_name,\n :password,\n :email,\n \t\t\t)\n\tend",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def college_whitelist_params\n params.require(:college_whitelist).permit(:status)\n end",
"def active_code_params\n params[:active_code].permit\n end",
"def filtering_params\n params.permit(:email)\n end",
"def valid_params(params)\n params.permit(:user_id, :photo_id, :originX, :originY, :width, :height)\n end",
"def ip_address_params\n\t\t\tparams.require(:ip_address).permit!\n end",
"def pull_request_params\n whitelist = [\n :url,\n :id,\n :html_url,\n :diff_url,\n :patch_url,\n :issue_url,\n :number,\n :state,\n :locked,\n :title\n ]\n params.require(:pull_request).permit(whitelist)\n end",
"def reserved_params\n params.require(:reserved).permit(:name, :email, :pax, :address, :KTP, :title)\n end",
"def post_params\n if current_user.admin? \n params.permit(:title, :body, :city, :country, :gps_location, :privacy, :visible, :latitude, :longitude, images: [], files: [])\n else \n params.permit(:title, :body, :city, :country, :gps_location, :privacy,:latitude, :longitude, images: [], files: [])\n end \n end",
"def list_params\n params.permit(:name)\n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def vineyard_params\n params.permit(:vineyard_name, :email, :website_url, :phone, :address, :city, :region, :postcode, :country, :specialty, :description, :pet_friendly, :holiday, :tours, :events, :family_friendly, :cover_image, :image_one, :image_two, :image_three, :image_four, :user_id, :base64)\n end",
"def available_activity_params\n # params.require(:available_activity).permit(:type,:geometry,:properties)\n whitelisted = ActionController::Parameters.new({\n type: params.require(:available_activity)[:type],\n geometry: params.require(:available_activity)[:geometry].try(:permit!).to_h,\n properties: params.require(:available_activity)[:properties].try(:permit!).to_h\n }).try(:permit!)\n end",
"def user_params\n params.permit(:name, :username, :email, :password, :img_url, :bg_url, :coinbank)\n end",
"def user_params_pub\n\t \tparams[:user].permit(:hruid)\n\t end",
"def user_params\n params.permit(:id, :email, :password, :nickname, :status, :avatar, :flat_picture, :flatsharing_id, :member,\n :user, :color, :solde)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def url_whitelist; end",
"def admin_social_network_params\n params.require(:social_network).permit!\n end",
"def filter_params\n params.require(:filters).permit(:letters)\n end",
"def origin_params\n params.permit(:country, :state, :city, :postal_code, :address, :description)\n end",
"def valid_params(params)\n params.permit(:login, :first_name, :last_name, \n :password, :password_confirmation)\n end",
"def sensitive_params=(params)\n @sensitive_params = params\n end",
"def permit_request_params\n params.permit(:address)\n end",
"def user_params\n # Ensure a user can't give themselves admin priveleges\n params.delete(:admin) if current_user.admin?\n params.require(:user).permit(:name, :email, :admin, :image)\n end",
"def secure_params\n params.require(:location).permit(:name)\n end",
"def strong_params\n params.require( :setting ).\n permit( :global_scan_limit, :per_user_scan_limit,\n :target_whitelist_patterns, :target_blacklist_patterns )\n end",
"def question_params\n params.require(:survey_question).permit(question_whitelist)\n end",
"def case_insensitive_params\n params.require(:case_insensitive).permit(:name)\n end",
"def empire_master_no_match_params\n params.require(:empire_master_no_match).permit(:uid, :last_name, :list, :search_date, :double, :source)\n end",
"def maintenance_request_params\n params[:maintenance_request].permit! #allow all parameters for now\n end",
"def unwanted_params\n params.require(:unwanted).permit(:title, :description, :image)\n end",
"def url_params\n params[:url].permit(:full)\n end",
"def backend_user_params\n params.permit!\n end",
"def filter_params\n\t\treturn params[:candidate].permit(:name_for_filter)\n\tend",
"def speed_measurement_params\n\n #fuckit, to lazy to deal with permit crap right now\n ActionController::Parameters.permit_all_parameters = true\n\n params[:speed_measurement]\n end",
"def user_params\n params.permit(:name, :age, :username, :display_photo, :password)\n end",
"def get_params\r\n #params.require(:article).permit(:title, :permalink, :content, :source_site, :introtext, :type_id, :order_by, :searchable, :created_by, :edited_by, :published_by, :published_on, :user_id)\r\n params.require(:article).permit!\r\n\r\n end",
"def pub_params\n params.require(:pub).permit(:name, :description, :phone, :email, :hidden, :city_id, :address)\n end",
"def pass_params\n params[:pass].permit(:name, :price, :description, :colour, :events)\n end",
"def droptraining_params\n params.permit(:training_id,:user_id, :utf8, :authenticity_token, :commit)\n end",
"def person_params\n # params whitelist does *not* include admin, sub, remember_token\n # TBD: share this whitelist with the list used by configuration_permitted_parameters\n # TBD: should current_password be on this list? -- for now, leaving off, since it seems to work without\n # NOTE: do not include 'admin' in this list!\n params.require(:person).permit(\n :name, \n :email, \n :description,\n :password, \n :password_confirmation\n )\n end",
"def parameter_params\n params.require(:parameter).permit(:name, :description, :param_code, :param_value, :active_from, :active_to)\n end"
] |
[
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",
"0.62894756",
"0.6283177",
"0.6242471",
"0.62382483",
"0.6217549",
"0.6214457",
"0.6209053",
"0.6193042",
"0.6177802",
"0.6174604",
"0.61714715",
"0.6161512",
"0.6151757",
"0.6150663",
"0.61461",
"0.61213595",
"0.611406",
"0.6106206",
"0.6105114",
"0.6089039",
"0.6081015",
"0.6071004",
"0.60620916",
"0.6019971",
"0.601788",
"0.6011056",
"0.6010898",
"0.6005122",
"0.6005122",
"0.6001556",
"0.6001049",
"0.59943926",
"0.5992201",
"0.59909594",
"0.5990628",
"0.5980841",
"0.59669393",
"0.59589154",
"0.5958826",
"0.5957911",
"0.5957385",
"0.5953072",
"0.59526145",
"0.5943361",
"0.59386164",
"0.59375334",
"0.59375334",
"0.5933856",
"0.59292704",
"0.59254247",
"0.5924164",
"0.59167904",
"0.59088355",
"0.5907542",
"0.59064597",
"0.5906243",
"0.5898226",
"0.589687",
"0.5896091",
"0.5894501",
"0.5894289",
"0.5891739",
"0.58860534",
"0.5882406",
"0.587974",
"0.58738774",
"0.5869024",
"0.58679986",
"0.5867561",
"0.5865932",
"0.5864461",
"0.58639693",
"0.58617616",
"0.5861436",
"0.5860451",
"0.58602303",
"0.5854586",
"0.58537364",
"0.5850427",
"0.5850199"
] |
0.0
|
-1
|
Change this eventually for better security supportsetup_fileserver
|
def setup_autosigning
<<-EOS
echo "*" > /etc/puppet/autosign.conf
EOS
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def public_file_server; end",
"def public_file_server; end",
"def public_file_server=(_arg0); end",
"def public_file_server=(_arg0); end",
"def file_handler_opts; end",
"def file_options; end",
"def file_utils; end",
"def runFileServer\n @@servlet = FileServlet.new(@@self_port)\n \n Thread.start {\n @@servlet.start() \n }\n \nend",
"def new_files; end",
"def test_configfile\n server = nil\n basedir = File.join(tmpdir, \"fileserverconfigfiletesting\")\n @@tmpfiles << basedir\n\n # make some dirs for mounting\n Dir.mkdir(basedir)\n mounts = {}\n %w{thing thus the-se those}.each { |dir|\n path = File.join(basedir, dir)\n Dir.mkdir(path)\n mounts[dir] = mktestfiles(path)\n\n }\n\n # create an example file with each of them\n conffile = tempfile\n @@tmpfiles << conffile\n\n File.open(conffile, \"w\") { |f|\n f.print \"# a test config file\n\n[thing]\n path #{basedir}/thing\n allow 192.168.0.*\n\n[thus]\n path #{basedir}/thus\n allow *.madstop.com, *.kanies.com\n deny *.sub.madstop.com\n\n[the-se]\n path #{basedir}/the-se\n\n[those]\n path #{basedir}/those\n\n\"\n }\n\n\n # create a server with the file\n assert_nothing_raised {\n\n server = Puppet::Network::Handler.fileserver.new(\n\n :Local => false,\n\n :Config => conffile\n )\n }\n\n list = nil\n # run through once with no host/ip info, to verify everything is working\n mounts.each { |mount, files|\n mount = \"/#{mount}/\"\n assert_nothing_raised {\n list = server.list(mount, :manage, true, false)\n }\n\n assert_nothing_raised {\n list.split(\"\\n\").each { |line|\n file, type = line.split(\"\\t\")\n\n desc = server.describe(mount + file)\n }\n }\n\n files.each { |f|\n assert_describe(mount, f, server)\n }\n }\n\n # now let's check that things are being correctly forbidden\n # this is just a map of names and expected results\n {\n \"thing\" => {\n :deny => [\n [\"hostname.com\", \"192.168.1.0\"],\n [\"hostname.com\", \"192.158.0.0\"]\n ],\n :allow => [\n [\"hostname.com\", \"192.168.0.0\"],\n [\"hostname.com\", \"192.168.0.245\"],\n ]\n },\n \"thus\" => {\n :deny => [\n [\"hostname.com\", \"192.168.1.0\"],\n [\"name.sub.madstop.com\", \"192.158.0.0\"]\n ],\n :allow => [\n [\"luke.kanies.com\", \"192.168.0.0\"],\n [\"luke.madstop.com\", \"192.168.0.245\"],\n ]\n }\n }.each { |mount, hash|\n mount = \"/#{mount}/\"\n\n # run through the map\n hash.each { |type, ary|\n ary.each { |sub|\n host, ip = sub\n\n case type\n when :deny\n\n assert_raise(\n Puppet::AuthorizationError,\n\n \"Host #{host}, ip #{ip}, allowed #{mount}\") {\n list = server.list(mount, :manage, true, false, host, ip)\n }\n when :allow\n assert_nothing_raised(\"Host #{host}, ip #{ip}, denied #{mount}\") {\n list = server.list(mount, :manage, true, false, host, ip)\n }\n end\n }\n }\n }\n\n end",
"def requested_file(request_line)\r\n # ... implementation details to be discussed later ...\r\nend",
"def file_server\n @file_server || (parent && parent.file_server)\n end",
"def file_uploads; end",
"def start_file_viewer\n success = false\n begin\n apps_dir = @apps_dir\n @file_auth = [VCAP.fast_uuid, VCAP.fast_uuid]\n auth = @file_auth\n @file_viewer_server = Thin::Server.new(@local_ip, @file_viewer_port, :signals => false) do\n Thin::Logging.silent = true\n use Rack::Auth::Basic do |username, password|\n [username, password] == auth\n end\n map '/droplets' do\n run DEA::Directory.new(apps_dir)\n end\n end\n @file_viewer_server.start!\n @logger.info(\"File service started on port: #{@file_viewer_port}\")\n @filer_start_attempts += 1\n success = true\n rescue => e\n @logger.fatal(\"Filer service failed to start: #{@file_viewer_port} already in use?: #{e}\")\n @filer_start_attempts += 1\n if @filer_start_attempts >= 5\n @logger.fatal(\"Giving up on trying to start filer, exiting...\")\n exit 1\n end\n end\n success\n end",
"def default_files; end",
"def hostfiles(options, which = T.unsafe(nil)); end",
"def test_seenewfiles\n server = nil\n testdir, pattern, tmpfile = mktestdir\n\n\n newfile = File.join(testdir, \"newfile\")\n\n # go through the whole schtick again...\n file = nil\n checks = Puppet::Network::Handler.fileserver::CHECKPARAMS\n\n assert_nothing_raised {\n\n server = Puppet::Network::Handler.fileserver.new(\n\n :Local => true,\n\n :Config => false\n )\n }\n\n assert_nothing_raised {\n server.mount(testdir, \"test\")\n }\n\n list = nil\n sfile = \"/test/\"\n assert_nothing_raised {\n list = server.list(sfile, :manage, true, false)\n }\n\n # create the new file\n File.open(newfile, \"w\") { |f|\n 3.times { f.puts rand(100) }\n }\n\n newlist = nil\n assert_nothing_raised {\n newlist = server.list(sfile, :manage, true, false)\n }\n\n # verify the list has changed\n assert(list != newlist)\n\n # and verify that we are specifically seeing the new file\n assert(newlist =~ /newfile/)\n end",
"def set_upload_file_to_server\n @upload_file_to_server = UploadFileToServer.find(params[:id])\n end",
"def test_fileserver_expansion\n server = nil\n assert_nothing_raised {\n\n server = Puppet::Network::Handler.fileserver.new(\n\n :Local => true,\n\n :Config => false\n )\n }\n\n dir = tempfile\n\n # When mocks attack, part 2\n kernel_fact = Facter.value(:kernel)\n\n ip = '127.0.0.1'\n\n\n Facter.stubs(:to_hash).returns(\n {\n :kernel => kernel_fact,\n :ipaddress => \"127.0.0.1\",\n :hostname => \"myhost\",\n :domain => \"mydomain.com\",\n\n })\n\n Dir.mkdir(dir)\n host = \"myhost.mydomain.com\"\n {\n \"%H\" => \"myhost.mydomain.com\", \"%h\" => \"myhost\", \"%d\" => \"mydomain.com\"\n }.each do |pattern, string|\n file = File.join(dir, string)\n mount = File.join(dir, pattern)\n File.open(file, \"w\") do |f| f.puts \"yayness: #{string}\" end\n name = \"name\"\n obj = nil\n assert_nothing_raised {\n obj = server.mount(mount, name)\n }\n obj.allow \"*\"\n\n ret = nil\n assert_nothing_raised do\n ret = server.list(\"/name\", :manage, false, false, host, ip)\n end\n\n assert_equal(\"/\\tfile\", ret)\n\n assert_nothing_raised do\n ret = server.describe(\"/name\", :manage, host, ip)\n end\n assert(ret =~ /\\tfile\\t/, \"Did not get valid a description (#{ret.inspect})\")\n\n assert_nothing_raised do\n ret = server.retrieve(\"/name\", :manage, host, ip)\n end\n\n assert_equal(ret, File.read(file))\n\n server.umount(name)\n\n File.unlink(file)\n end\n end",
"def server_root \n end",
"def files; end",
"def files; end",
"def files; end",
"def files; end",
"def files; end",
"def files; end",
"def setup(server)\n @server = server\n @server.on('beforeMethod', method(:before_method))\n @server.on('beforeCreateFile', method(:before_create_file))\n end",
"def test_filereread\n server = nil\n\n conffile = tempfile\n dir = tstdir\n\n files = mktestfiles(dir)\n File.open(conffile, \"w\") { |f|\n f.print \"# a test config file\n\n[thing]\n path #{dir}\n allow test1.domain.com\n\"\n }\n\n # Reset the timeout, so we reload faster\n Puppet[:filetimeout] = 0.5\n\n # start our server with a fast timeout\n assert_nothing_raised {\n\n server = Puppet::Network::Handler.fileserver.new(\n\n :Local => false,\n\n :Config => conffile\n )\n }\n\n list = nil\n assert_nothing_raised {\n\n list = server.list(\n \"/thing/\", :manage, false, false,\n\n \"test1.domain.com\", \"127.0.0.1\")\n }\n assert(list != \"\", \"List returned nothing in rereard test\")\n\n assert_raise(Puppet::AuthorizationError, \"List allowed invalid host\") {\n list = server.list(\"/thing/\", :manage, false, false, \"test2.domain.com\", \"127.0.0.1\")\n }\n\n sleep 1\n File.open(conffile, \"w\") { |f|\n f.print \"# a test config file\n\n[thing]\n path #{dir}\n allow test2.domain.com\n\"\n }\n\n assert_raise(Puppet::AuthorizationError, \"List allowed invalid host\") {\n list = server.list(\"/thing/\", :manage, false, false, \"test1.domain.com\", \"127.0.0.1\")\n }\n\n assert_nothing_raised {\n list = server.list(\"/thing/\", :manage, false, false, \"test2.domain.com\", \"127.0.0.1\")\n }\n\n assert(list != \"\", \"List returned nothing in rereard test\")\n\n list = nil\n end",
"def create_server\n\n end",
"def security_server_client\n end",
"def existing_files; end",
"def prepare(server); end",
"def setup\n\n @server = ItemServer.new :auth => :basic\n @server.start\n end",
"def test_getfilelist\n server = nil\n testdir, pattern, tmpfile = mktestdir\n\n file = nil\n\n assert_nothing_raised {\n\n server = Puppet::Network::Handler.fileserver.new(\n\n :Local => true,\n\n :Config => false\n )\n }\n\n assert_nothing_raised {\n server.mount(testdir, \"test\")\n }\n\n # get our listing\n list = nil\n sfile = \"/test/tmpfile\"\n assert_nothing_raised {\n list = server.list(sfile, :manage, true, false)\n }\n\n output = \"/\\tfile\"\n\n # verify it got listed as a file\n assert_equal(output, list)\n\n # verify we got all fields\n assert(list !~ /\\t\\t/)\n\n # verify that we didn't get the directory itself\n list.split(\"\\n\").each { |line|\n assert(line !~ %r{remotefile})\n }\n\n # and then verify that the contents match\n contents = File.read(tmpfile)\n\n ret = nil\n assert_nothing_raised {\n ret = server.retrieve(sfile)\n }\n\n assert_equal(contents, ret)\n end",
"def setup_server(s)\n # noop\n end",
"def mount_path; end",
"def init_file; end",
"def establish_file_descriptor_server\n @file_descriptor_server = FileDescriptorServer.new(socket_server)\n @file_descriptor_server.socket_server\n end",
"def _ROOT_FILE_STORE\n return \"/home/cesteam/cloudstorge/\"\nend",
"def initialize(args)\n if args.class == Nextcloud::WebdavApi\n @api = args\n else\n super\n @api = self\n end\n\n @path = \"/files/#{@api.username}\"\n end",
"def file_handler\n @_element_file_handler = ElementFileHandler.new(keytechkit.base_url, keytechkit.username, keytechkit.password) if @_element_file_handler.nil?\n @_element_file_handler\n end",
"def file; end",
"def file; end",
"def file; end",
"def file; end",
"def file; end",
"def file; end",
"def file; end",
"def file; end",
"def file; end",
"def file; end",
"def file; end",
"def applicable_files; end",
"def server; end",
"def server; end",
"def server; end",
"def server; end",
"def server; end",
"def server; end",
"def server; end",
"def server; end",
"def modify_file\n\n file_name = \"#{ node[\"php_fpm\"][\"pools_path\"] }/#{ @current_resource.pool_name }.conf\"\n\n #Start Base Configuration\n find_replace(file_name, \"user = \", @current_resource.pool_user, @new_resource.pool_user)\n find_replace(file_name, \"group = \", @current_resource.pool_group, @new_resource.pool_group)\n\n #Replace IP Address and Port\n if @current_resource.listen_address != @new_resource.listen_address || @current_resource.listen_port != @new_resource.listen_port && (!@current_resource.use_sockets)\n find_replace(file_name, \"listen = \", \"#{ @current_resource.listen_address }:#{ @current_resource.listen_port }\", \"#{ @new_resource.listen_address }:#{ @new_resource.listen_port }\")\n else\n find_replace(file_name, \"listen = \",\"#{ @current_resource.listen_socket }\", \"#{ @new_resource.listen_socket }\")\n end\n\n @new_resource.listen_allowed_clients != nil ? find_replace(file_name, \"listen.allowed_clients = \",@current_resource.listen_allowed_clients, @new_resource.listen_allowed_clients) : nil\n @new_resource.listen_owner != nil ? find_replace(file_name, \"listen.owner = \",@current_resource.listen_owner, @new_resource.listen_owner) : nil\n @new_resource.listen_group != nil ? find_replace(file_name, \"listen.group = \",@current_resource.listen_group, @new_resource.listen_group) : nil\n @new_resource.listen_mode != nil ? find_replace(file_name, \"listen.mode = \",@current_resource.listen_mode, @new_resource.listen_mode) : nil\n @new_resource.listen_backlog != nil ? find_replace(file_name, \"listen.backlog = \",@current_resource.listen_backlog, @new_resource.listen_backlog) : nil\n\n #Start PM configuration\n @new_resource.pm != nil ? find_replace(file_name, \"pm = \",@current_resource.pm,@new_resource.pm) : nil\n @new_resource.pm_max_children != nil ? find_replace(file_name, \"pm.max_children = \",@current_resource.pm_max_children, @new_resource.pm_max_children) : nil\n @new_resource.pm_start_servers != nil ? find_replace(file_name, \"pm.start_servers = \",@current_resource.pm_start_servers, @new_resource.pm_start_servers) : nil\n @new_resource.pm_min_spare_servers != nil ? find_replace(file_name, \"pm.min_spare_servers = \",@current_resource.pm_min_spare_servers, @new_resource.pm_min_spare_servers) : nil\n @new_resource.pm_max_spare_servers != nil ? find_replace(file_name, \"pm.max_spare_servers = \",@current_resource.pm_max_spare_servers, @new_resource.pm_max_spare_servers) : nil\n @new_resource.pm_process_idle_timeout != nil ? find_replace(file_name, \"pm.process_idle_timeout = \",@current_resource.pm_process_idle_timeout, @new_resource.pm_process_idle_timeout) : nil\n @new_resource.pm_max_requests != nil ? find_replace(file_name, \"pm.max_requests = \",@current_resource.pm_max_requests, @new_resource.pm_max_requests) : nil\n @new_resource.pm_status_path != nil ? find_replace(file_name, \"pm.status_path = \",@current_resource.pm_status_path, @new_resource.pm_status_path) : nil\n\n #Start Ping\n @new_resource.ping_path != nil ? find_replace(file_name, \"ping.path = \",@current_resource.ping_path, @new_resource.ping_path) : nil\n @new_resource.ping_response != nil ? find_replace(file_name, \"ping.response = \",@current_resource.ping_response, @new_resource.ping_response) : nil\n\n #Start Logging\n @new_resource.access_format != nil ? find_replace(file_name, \"access.format = \",@current_resource.access_format, @new_resource.access_format.gsub(\"\\\\\",\"\")) : nil\n @new_resource.request_slowlog_timeout != nil ? find_replace(file_name, \"request_slowlog_timeout = \",@current_resource.request_slowlog_timeout, @new_resource.request_slowlog_timeout) : nil\n @new_resource.request_terminate_timeout != nil ? find_replace(file_name, \"request_terminate_timeout = \",@current_resource.request_terminate_timeout, @new_resource.request_terminate_timeout) : nil\n @new_resource.access_log != nil ? find_replace(file_name, \"access.log = \",@current_resource.access_log, @new_resource.access_log) : nil\n @new_resource.slow_log != nil ? find_replace(file_name, \"slowlog = \",@current_resource.slow_log, @new_resource.slow_log) : nil\n\n #Start Misc\n @new_resource.chdir != nil ? find_replace(file_name, \"chdir = \",@current_resource.chdir, @new_resource.chdir) : nil\n @new_resource.chroot != nil ? find_replace(file_name, \"chroot = \",@current_resource.chroot, @new_resource.chroot) : nil\n @new_resource.catch_workers_output != nil ? find_replace(file_name, \"catch_workers_output = \",@current_resource.catch_workers_output, @new_resource.catch_workers_output) : nil\n @new_resource.security_limit_extensions != nil ? find_replace(file_name, \"security.limit_extensions = \",@current_resource.security_limit_extensions, @new_resource.security_limit_extensions) : nil\n @new_resource.rlimit_files != nil ? find_replace(file_name, \"rlimit_files = \",@current_resource.rlimit_files, @new_resource.rlimit_files) : nil\n @new_resource.rlimit_core != nil ? find_replace(file_name, \"rlimit_core = \",@current_resource.rlimit_core, @new_resource.rlimit_core) : nil\n\n #Start PHP INI Values\n if !@current_resource.php_ini_values.nil?\n @current_resource.php_ini_values.each do | k, v |\n find_replace(file_name, \"php_value[#{ k }] = \", v, @new_resource.php_ini_values[\"#{ k }\"])\n end\n end\n\n #Start PHP INI Flags\n if !@current_resource.php_ini_flags.nil?\n @current_resource.php_ini_flags.each do | k, v |\n find_replace(file_name, \"php_flag[#{ k }] = \", v, @new_resource.php_ini_flags[\"#{ k }\"])\n end\n end\n\n #Start PHP INI Admin Values\n if !@current_resource.php_ini_admin_values.nil?\n @current_resource.php_ini_admin_values.each do | k, v |\n find_replace(file_name, \"php_admin_value[#{ k }] = \", v, @new_resource.php_ini_admin_values[\"#{ k }\"])\n end\n end\n\n #Start PHP INI Admin Flags\n if !@current_resource.php_ini_admin_flags.nil?\n @current_resource.php_ini_admin_flags.each do | k, v |\n find_replace(file_name, \"php_admin_flag[#{ k }] = \", v, @new_resource.php_ini_admin_flags[\"#{ k }\"])\n end\n end\n\n #Start ENV Variables\n if !@current_resource.env_variables.nil?\n @current_resource.env_variables.each do | k, v |\n find_replace(file_name, \"env[#{ k }] = \",v,@new_resource.env_variables[\"#{ k }\"])\n end\n end\n\nend",
"def set_file_priv()\n FileUtils.chmod 0644, @setting_file_path\n FileUtils.chmod 0644, @root_cert_kc_path\n end",
"def script_settings_files_def\n {\n 'adjust_permissions.dirs' => {\n :uid => sftp_user_uid,\n :gid => group_gid,\n :reject_mmask => 0007 }\n }\nend",
"def setup_handler\n\t\t# Start the HTTP server service on this host/port\n\t\tself.service = Rex::ServiceManager.start(Rex::Proto::Http::Server,\n\t\t\tdatastore['PXPORT'].to_i, datastore['PXHOST'])\n\n\t\t# Add the new resource\n\t\tservice.add_resource(datastore['PXURI'],\n\t\t\t'Proc' => Proc.new { |cli, req|\n\t\t\t\ton_request(cli, req)\n\t\t\t},\n\t\t\t'VirtualDirectory' => true)\n\n\t\tdlog(\"PassiveX listener started on http://#{datastore['PXHOST']}:#{datastore['PXPORT']}#{datastore['PXURI']}\", 'core', LEV_2)\n\n\t\tprint_status(\"PassiveX listener started.\")\n\tend",
"def config_server\n file = File.open(\"#{@project_name}/server.rb\", \"r+\")\n file.each do |line|\t \n while line == \" def response(env)\\n\" do\n pos = file.pos\n rest = file.read\n file.seek pos\n file.write(\"\\t::\") \n file.write(@module_name)\n file.write(\"::Base.call(env)\\n\")\n file.write(rest)\n $stdout.puts \"\\e[1;35m \\tconfig\\e[0m\\tserver.rb\"\n return\n end\n end\n end",
"def send_file_info(last, path)\n if not last == nil\n user = current_user\n path = path.force_encoding(\"UTF-8\")\n @file_names = \"#{path.split('/').last}\" + \"\\n\"\n @access_url = \"#{HOSTING_URL}\" + \"/user_files/\"+ \"#{user.userid}\" + path.force_encoding(\"UTF-8\") \n \n else\n @file_names = \"error\"\n @access_url = \"\"\n end\n puts_message \"send_file_info end\" \n end",
"def root_file_path; end",
"def tcp_wrappers_filename\n new_resource.name.gsub(/[\\.~]/, '__')\nend",
"def server_put_file(server, io, remote_path, options={})\n request(\n :method => :post,\n :path => \"containers/#{server.id}/files\",\n :params => {\n :path => remote_path\n },\n :body => io,\n :headers => {\n 'Transfer-Encoding' => 'chunked',\n 'X-LXD-uid' => options.fetch(:uid, 0),\n 'X-LXD-gid' => options.fetch(:gid, 0),\n 'X-LXD-mode' => options.fetch(:mode, 0700)\n }\n )\n true\n end",
"def storage_use_nfs\n super\n end",
"def file_up(platform, dir)\r\n # specifying an extension by platform\r\n if platform == Msf::Module::Platform::Windows\r\n filex = \".bat\"\r\n else\r\n if payload.encoded =~ /sh/\r\n filex = \".sh\"\r\n elsif payload.encoded =~ /perl/\r\n filex = \".pl\"\r\n elsif payload.encoded =~ /python/\r\n filex = \".py\"\r\n elsif payload.encoded =~ /ruby/\r\n filex = \".rb\"\r\n else\r\n fail_with(Failure::Unknown, 'Payload type could not be checked!')\r\n end\r\n end\r\n \r\n @fname= rand_text_alpha(9 + rand(3)) + filex\r\n data = Rex::MIME::Message.new\r\n data.add_part('./', nil, nil, 'form-data; name=\"uploadDir\"')\r\n data.add_part(payload.encoded, 'application/octet-stream', nil, \"form-data; name=\\\"theFile\\\"; filename=\\\"#{@fname}\\\"\")\r\n \r\n res = send_request_cgi({\r\n 'method' => 'POST', \r\n 'data' => data.to_s,\r\n 'agent' => 'Mozilla',\r\n 'ctype' => \"multipart/form-data; boundary=#{data.bound}\",\r\n 'cookie' => @cookie,\r\n 'uri' => normalize_uri(target_uri, \"Upload.do\") \r\n })\r\n \r\n if res && res.code == 200 && res.body.include?('icon_message_success') # Success icon control\r\n print_good(\"#{@fname} malicious file has been uploaded.\")\r\n create_exec_prog(dir, @fname) # Great. Let's send them somewhere else o_O\r\n else\r\n fail_with(Failure::Unknown, 'The file could not be uploaded!')\r\n end\r\n end",
"def server_attach(dbname, mode)\n #This is a stub, used for indexing\n end",
"def test_host_specific\n client1 = \"client1.example.com\"\n client2 = \"client2.example.com\"\n ip = \"127.0.0.1\"\n\n # Setup a directory hierarchy for the tests\n fsdir = File.join(tmpdir, \"host-specific\")\n @@tmpfiles << fsdir\n hostdir = File.join(fsdir, \"host\")\n fqdndir = File.join(fsdir, \"fqdn\")\n client1_hostdir = File.join(hostdir, \"client1\")\n client2_fqdndir = File.join(fqdndir, client2)\n contents = {\n client1_hostdir => \"client1\\n\",\n client2_fqdndir => client2 + \"\\n\"\n }\n [fsdir, hostdir, fqdndir, client1_hostdir, client2_fqdndir].each { |d| Dir.mkdir(d) }\n\n [client1_hostdir, client2_fqdndir].each do |d|\n File.open(File.join(d, \"file.txt\"), \"w\") do |f|\n f.print contents[d]\n end\n end\n conffile = tempfile\n File.open(conffile, \"w\") do |f|\n f.print(\"\n[host]\npath #{hostdir}/%h\nallow *\n[fqdn]\npath #{fqdndir}/%H\nallow *\n\")\n end\n\n server = nil\n assert_nothing_raised {\n\n server = Puppet::Network::Handler.fileserver.new(\n\n :Local => true,\n\n :Config => conffile\n )\n }\n\n # check that list returns the correct thing for the two clients\n list = nil\n sfile = \"/host/file.txt\"\n assert_nothing_raised {\n list = server.list(sfile, :manage, true, false, client1, ip)\n }\n assert_equal(\"/\\tfile\", list)\n assert_nothing_raised {\n list = server.list(sfile, :manage, true, false, client2, ip)\n }\n assert_equal(\"\", list)\n\n sfile = \"/fqdn/file.txt\"\n assert_nothing_raised {\n list = server.list(sfile, :manage, true, false, client1, ip)\n }\n assert_equal(\"\", list)\n assert_nothing_raised {\n list = server.list(sfile, :manage, true, false, client2, ip)\n }\n assert_equal(\"/\\tfile\", list)\n\n # check describe\n sfile = \"/host/file.txt\"\n assert_nothing_raised {\n list = server.describe(sfile, :manage, client1, ip).split(\"\\t\")\n }\n assert_equal(5, list.size)\n assert_equal(\"file\", list[1])\n md5 = Digest::MD5.hexdigest(contents[client1_hostdir])\n assert_equal(\"{md5}#{md5}\", list[4])\n\n assert_nothing_raised {\n list = server.describe(sfile, :manage, client2, ip).split(\"\\t\")\n }\n assert_equal([], list)\n\n sfile = \"/fqdn/file.txt\"\n assert_nothing_raised {\n list = server.describe(sfile, :manage, client1, ip).split(\"\\t\")\n }\n assert_equal([], list)\n\n assert_nothing_raised {\n list = server.describe(sfile, :manage, client2, ip).split(\"\\t\")\n }\n assert_equal(5, list.size)\n assert_equal(\"file\", list[1])\n md5 = Digest::MD5.hexdigest(contents[client2_fqdndir])\n assert_equal(\"{md5}#{md5}\", list[4])\n\n # Check retrieve\n sfile = \"/host/file.txt\"\n assert_nothing_raised {\n list = server.retrieve(sfile, :manage, client1, ip).chomp\n }\n assert_equal(contents[client1_hostdir].chomp, list)\n\n assert_nothing_raised {\n list = server.retrieve(sfile, :manage, client2, ip).chomp\n }\n assert_equal(\"\", list)\n\n sfile = \"/fqdn/file.txt\"\n assert_nothing_raised {\n list = server.retrieve(sfile, :manage, client1, ip).chomp\n }\n assert_equal(\"\", list)\n\n assert_nothing_raised {\n list = server.retrieve(sfile, :manage, client2, ip).chomp\n }\n assert_equal(contents[client2_fqdndir].chomp, list)\n end",
"def compression_server; end",
"def test_listedpath\n server = nil\n assert_nothing_raised {\n\n server = Puppet::Network::Handler.fileserver.new(\n\n :Local => true,\n\n :Config => false\n )\n }\n\n\n # create a deep dir\n basedir = tempfile\n testdir = \"#{basedir}/with/some/sub/directories/for/testing\"\n oldfile = File.join(testdir, \"oldfile\")\n assert_nothing_raised {\n system(\"mkdir -p #{testdir}\")\n File.open(oldfile, \"w\") { |f|\n 3.times { f.puts rand(100) }\n }\n @@tmpfiles << basedir\n }\n\n # mounty mounty\n assert_nothing_raised {\n server.mount(basedir, \"localhost\")\n }\n\n list = nil\n # and then check a few dirs\n assert_nothing_raised {\n list = server.list(\"/localhost/with\", :manage, false, false)\n }\n\n assert(list !~ /with/)\n\n assert_nothing_raised {\n list = server.list(\"/localhost/with/some/sub\", :manage, true, false)\n }\n\n assert(list !~ /sub/)\n end",
"def static_files=(_arg0); end",
"def _FILESDIR; Config._FILES; end",
"def file_path; end",
"def script_security\n security_fail(\"Webdir #{options['webdir']} does not exist. Please fix!\") unless File.directory?(options['webdir'])\nend",
"def script_security\n security_fail(\"Webdir #{options['webdir']} does not exist. Please fix!\") unless File.directory?(options['webdir'])\nend",
"def script_security\n security_fail(\"Webdir #{options['webdir']} does not exist. Please fix!\") unless File.directory?(options['webdir'])\nend",
"def script_security\n security_fail(\"Webdir #{options['webdir']} does not exist. Please fix!\") unless File.directory?(options['webdir'])\nend",
"def file_utils=(_arg0); end",
"def path(k)\n case k\n when :ascp,:ascp4\n use_ascp_from_product(FIRST_FOUND) if @path_to_ascp.nil?\n file=@path_to_ascp\n # note that there might be a .exe at the end\n file=file.gsub('ascp','ascp4') if k.eql?(:ascp4)\n when :ssh_bypass_key_dsa\n file=File.join(folder_path,'aspera_bypass_dsa.pem')\n File.write(file,get_key('dsa',1)) unless File.exist?(file)\n File.chmod(0400,file)\n when :ssh_bypass_key_rsa\n file=File.join(folder_path,'aspera_bypass_rsa.pem')\n File.write(file,get_key('rsa',2)) unless File.exist?(file)\n File.chmod(0400,file)\n when :aspera_license\n file=File.join(folder_path,'aspera-license')\n File.write(file,Base64.strict_encode64(\"#{Zlib::Inflate.inflate(DataRepository.instance.get_bin(6))}==SIGNATURE==\\n#{Base64.strict_encode64(DataRepository.instance.get_bin(7))}\")) unless File.exist?(file)\n File.chmod(0400,file)\n when :aspera_conf\n file=File.join(folder_path,'aspera.conf')\n File.write(file,%Q{<?xml version='1.0' encoding='UTF-8'?>\n<CONF version=\"2\">\n<default>\n <file_system>\n <storage_rc>\n <adaptive>\n true\n </adaptive>\n </storage_rc>\n <resume_suffix>.aspera-ckpt</resume_suffix>\n <partial_file_suffix>.partial</partial_file_suffix>\n <replace_illegal_chars>_</replace_illegal_chars>\n </file_system>\n</default>\n</CONF>\n}) unless File.exist?(file)\n File.chmod(0400,file)\n when :fallback_cert,:fallback_key\n file_key=File.join(folder_path,'aspera_fallback_key.pem')\n file_cert=File.join(folder_path,'aspera_fallback_cert.pem')\n if !File.exist?(file_key) or !File.exist?(file_cert)\n require 'openssl'\n # create new self signed certificate for http fallback\n private_key = OpenSSL::PKey::RSA.new(1024)\n cert = OpenSSL::X509::Certificate.new\n cert.subject = cert.issuer = OpenSSL::X509::Name.parse(\"/C=US/ST=California/L=Emeryville/O=Aspera Inc./OU=Corporate/CN=Aspera Inc./emailAddress=info@asperasoft.com\")\n cert.not_before = Time.now\n cert.not_after = Time.now + 365 * 24 * 60 * 60\n cert.public_key = private_key.public_key\n cert.serial = 0x0\n cert.version = 2\n cert.sign(private_key, OpenSSL::Digest::SHA1.new)\n File.write(file_key,private_key.to_pem)\n File.write(file_cert,cert.to_pem)\n File.chmod(0400,file_key)\n File.chmod(0400,file_cert)\n end\n file = k.eql?(:fallback_cert) ? file_cert : file_key\n else\n raise \"INTERNAL ERROR: #{k}\"\n end\n raise \"no such file: #{file}\" unless File.exist?(file)\n return file\n end",
"def config_files(override); end",
"def encryption_server; end",
"def create_server\n\t\treturn Hglib::Server.new( self.path.to_s )\n\tend",
"def directory_handlers\n \"#{serf_path}/handlers\"\nend",
"def set_security_file\n begin\n @security_file = SecurityFile.first\n\n unless @security_file\n render status: :not_found\n end\n rescue\n render status: :not_found\n end\n end",
"def directory_path\n @directory_path || Ferver::DEFAULT_FILE_SERVER_DIR_PATH\n end",
"def file_watcher; end",
"def file_watcher; end",
"def server_flags; end",
"def set_file\n if have_file?\n begin\n set_file_for_remote_storage\n rescue Errno::ENOENT\n set_file_for_local_storage\n rescue NoMethodError\n raise \"Original resource has no File\"\n end\n else\n raise \"Original resource has no File\"\n end\n end",
"def file_url\n end",
"def set_ftp_server\r\n @ftp_server = FtpServer.find(params[:id])\r\n end",
"def on_other_file; end",
"def static_files; end",
"def script_settings_files_def\nend",
"def file_handler_opts\n WEBrick::Config::FileHandler.merge(\n FancyIndexing: true,\n NondisclosureName: [\n \".ht*\", \"~*\",\n ]\n )\n end"
] |
[
"0.7538976",
"0.7538976",
"0.74575835",
"0.74575835",
"0.6470444",
"0.6065189",
"0.60561615",
"0.59861195",
"0.59857917",
"0.5959054",
"0.5942652",
"0.5895407",
"0.58773345",
"0.58416224",
"0.5839264",
"0.5838764",
"0.5838069",
"0.5807039",
"0.5790493",
"0.5785617",
"0.5778932",
"0.5778932",
"0.5778932",
"0.5778932",
"0.5778932",
"0.5778932",
"0.5747072",
"0.5735399",
"0.57148856",
"0.57122314",
"0.56863755",
"0.56846255",
"0.56330615",
"0.5627546",
"0.5623118",
"0.56217396",
"0.5611575",
"0.5590346",
"0.5582247",
"0.5563857",
"0.5543529",
"0.5540181",
"0.5540181",
"0.5540181",
"0.5540181",
"0.5540181",
"0.5540181",
"0.5540181",
"0.5540181",
"0.5540181",
"0.5540181",
"0.5540181",
"0.55391955",
"0.5533865",
"0.5533865",
"0.5533865",
"0.5533865",
"0.5533865",
"0.5533865",
"0.5533865",
"0.5533865",
"0.55276465",
"0.5518857",
"0.55179834",
"0.55055535",
"0.5489054",
"0.54875916",
"0.54781747",
"0.54747814",
"0.5457113",
"0.5453685",
"0.54266304",
"0.54185563",
"0.5418246",
"0.54123515",
"0.5406823",
"0.5400271",
"0.5394963",
"0.5391929",
"0.53848886",
"0.53848886",
"0.53848886",
"0.53848886",
"0.53751564",
"0.5375073",
"0.53654397",
"0.53597116",
"0.53576887",
"0.53567797",
"0.5354213",
"0.5350335",
"0.53446054",
"0.53446054",
"0.5335865",
"0.5333761",
"0.5332755",
"0.5328491",
"0.53242695",
"0.5323725",
"0.5320745",
"0.531393"
] |
0.0
|
-1
|
Takes a number and options hash and outputs a string in any currency format. CREDIT:
|
def currencify(number, options={})
return "$0.00" if number.nil?
# default format: $12,345,678.90
options = {
:currency_symbol => "$",
:delimiter => ",",
:decimal_symbol => ".",
:currency_before => true
}.merge(options)
# split integer and fractional parts
int, frac = ("%.2f" % number).split('.')
# insert the delimiters
int.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{options[:delimiter]}")
if options[:currency_before]
options[:currency_symbol] + int + options[:decimal_symbol] + frac
else
int + options[:decimal_symbol] + frac + options[:currency_symbol]
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def show_price(options = {})\n price_unpacked.to_s + '€ per piece, ' + price_packed.to_s + '€ per box'\n end",
"def to_s(options = {})\n return amount.to_f.to_s if options[:exact]\n self.format(:symbol => false)\n end",
"def pretty_currency_formatted(options={})\n if self == 0.00\n \"free\"\n else\n if options[:no_dollar_sign]\n \"#{self.currency_formatted}\"\n else\n \"$#{self.currency_formatted}\"\n end\n end \n end",
"def currency_as_string; end",
"def format(options = {})\n options[:precision] ||= self.class.default_precision\n options[:hide_symbol] ||= false\n \n out = \"\"\n out += self.currency_symbol unless options[:hide_symbol]\n out += sprintf(\"%.#{options[:precision]}f\", self.to_f )\n end",
"def format\n \"#{amount} #{currency}\"\n end",
"def currency_as_string=(val); end",
"def to_s(options={})\n Money::Formatter.format(self, options)\n end",
"def currencify(number, options={})\n # :currency_before => false puts the currency symbol after the number\n # default format: $12,345,678.90\n options = {:currency_symbol => \"$\", :delimiter => \",\", :decimal_symbol => \".\", :currency_before => true}.merge(options)\n \n # split integer and fractional parts \n int, frac = (\"%.2f\" % number).split('.')\n # insert the delimiters\n int.gsub!(/(\\d)(?=(\\d\\d\\d)+(?!\\d))/, \"\\\\1#{options[:delimiter]}\")\n \n if options[:currency_before]\n options[:currency_symbol] + int + options[:decimal_symbol] + frac\n else\n int + options[:decimal_symbol] + frac + options[:currency_symbol]\n end\n\n end",
"def to_s\n context = @solution.map {|k, v| \"#{k}: #{v}\"}.join(',')\n \"#<Twilio.Pricing.V2.NumberContext #{context}>\"\n end",
"def price_as_string()\n return \"$%0.2f\" %[@price]\n end",
"def occ_option_symbol(underlying_symbol, expiration_yymmdd, call_or_put, strike_price)\n root_symbol = underlying_symbol.strip.upcase.ljust(6, ' ')\n expiration = expiration_yymmdd\n type = call_or_put\n strike = (strike_price.to_f * 1000).round.to_s.rjust(8, '0')\n \"#{root_symbol}#{expiration}#{type}#{strike}\"\n end",
"def stringify amount, currency, opts={}\n definition = definitions[currency]\n separators = definition[:separators] || {}\n format = \"%.#{definition[:minor_unit]}f\"\n string = format % amount\n major, minor = string.split('.')\n\n major.gsub!(/(\\d)(?=(\\d\\d\\d)+(?!\\d))/) { $1 + separators[:major] } if separators[:major] && opts[:format] != :plain\n\n string = minor ? major + (opts[:format] == :plain || !separators[:minor] ? '.' : separators[:minor]) + minor : major\n pre = [[:amount, :plain].include?(opts[:format]) && '', opts[:format] == :symbol && definition[:symbol], currency.to_s.upcase + ' '].detect{|a| a.is_a?(String)}\n\n \"#{pre}#{string}\"\n end",
"def price_string\n\n money = self.price || 0\n copper = money % 100\n amount = (money - copper) / 100\n silver = amount % 100\n gold = (amount - silver) / 100\n\n parts = []\n parts << \"#{number_with_delimiter(gold.to_i)}g\" if gold > 0\n parts << \"#{silver.to_i}s\" if silver > 0\n parts << \"#{copper.to_i}c\" if copper > 0\n\n parts.join(' ')\n \n end",
"def price_as_string \n price_format = 0.0\n price_format = \"$%.2f\" % @price #formatstring\n price_format\n end",
"def currency_as_string\n currency.to_s\n end",
"def currency_as_string\n currency.to_s\n end",
"def wrt_retail_prc(price, options = {})\n format = options[:format] || 6\n $report_file.puts(\"Retail Price:\" + \"%#{format}s\" % \"$\" + price.to_s)\nend",
"def currencify(number, options={})\n # :currency_before => false puts the currency symbol after the number\n # default format: $12,345,678.90\n options = {:currency_symbol => \"$\", :delimiter => \",\", :decimal_symbol => \".\", :currency_before => true}.merge(options)\n\n # split integer and fractional parts\n int, frac = (\"%.2f\" % number).split('.')\n # insert the delimiters\n int.gsub!(/(\\d)(?=(\\d\\d\\d)+(?!\\d))/, \"\\\\1#{options[:delimiter]}\")\n\n if options[:currency_before]\n options[:currency_symbol] + int + options[:decimal_symbol] + frac\n else\n int + options[:decimal_symbol] + frac + options[:currency_symbol]\n end\n end",
"def currencify(number, options={})\n # :currency_before => false puts the currency symbol after the number\n # default format: $12,345,678.90\n options = {:currency_symbol => \"$\", :delimiter => \",\", :decimal_symbol => \".\", :currency_before => true}.merge(options)\n\n # split integer and fractional parts\n int, frac = (\"%.2f\" % number).split('.')\n # insert the delimiters\n int.gsub!(/(\\d)(?=(\\d\\d\\d)+(?!\\d))/, \"\\\\1#{options[:delimiter]}\")\n\n if options[:currency_before]\n options[:currency_symbol] + int + options[:decimal_symbol] + frac\n else\n int + options[:decimal_symbol] + frac + options[:currency_symbol]\n end\n end",
"def price_as_string\n \"$%.2f\" % @price\n end",
"def string_from_number(number)\n if @style == :dash\n number = number.to_i\n return \"#{number / Dash::COIN}.#{'%08d' % [number % Dash::COIN]}\".gsub(/0+$/,\"\").gsub(/\\.$/,\".0\")\n elsif @style == :dash_long\n number = number.to_i\n return \"#{number / Dash::COIN}.#{'%08d' % [number % Dash::COIN]}\"\n else\n # TODO: parse other styles\n raise \"Not implemented\"\n end\n end",
"def format(number, options={})\n return nil unless number\n\n # options[:format] ||= :parens\n code,num = strip_country_code(normalize_phone_number(number))\n code ||= \"1\" if options[:country_code]\n case options[:format]\n when :parens\n (options[:country_code] ? \"+#{code} \" : '' ) + \"(#{num[0..2]}) #{num[3..5]} #{num[6..9]}\"\n when :dashes\n (options[:country_code] ? \"+#{code}-\" : '' ) + \"#{num[0..2]}-#{num[3..5]}-#{num[6..9]}\"\n when :spaces\n (options[:country_code] ? \"+#{code} \" : '' ) + \"#{num[0..2]} #{num[3..5]} #{num[6..9]}\"\n else\n (options[:country_code] ? \"+#{code}\" : '' ) + num\n end\n end",
"def string_from_number(number)\n if @style == :btc\n number = number.to_i\n return \"#{number / BTC::COIN}.#{'%08d' % [number % BTC::COIN]}\".gsub(/0+$/,\"\").gsub(/\\.$/,\".0\")\n elsif @style == :btc_long\n number = number.to_i\n return \"#{number / BTC::COIN}.#{'%08d' % [number % BTC::COIN]}\"\n else\n # TODO: parse other styles\n raise \"Not implemented\"\n end\n end",
"def price_as_string\n output = '%.2f' % price\n \"$\"+output.to_s\nend",
"def price_as_string\n return \"$%0.2f\" % [@price]\n end",
"def price_as_string\n \"$\"+\"%.2f\" % @price\n end",
"def invoice options={}\n puts options[:company]\n puts options[:total]\n puts options[:etc]\n puts options[:tax]\nend",
"def price_as_string\n \"$\"+format(\"%0.2f\",@price)\n end",
"def price_as_string\n \"$\"+\"%0.2f\" % @price\n end",
"def price_as_a_string()\n puts format(\"$%.2f\", @price)\n end",
"def price_as_string\n return \"$%.2f\" % @price.to_f #PassAll:price_as_string\n end",
"def format_currency(amount, chopOff)\n result = amount.to_s\n if chopOff\n 2.times do result.chop! end #takes off the .0\n end\n if result.length <= 3\n result = \"$\" + result\n elsif result.length >= 4 && result.length <=6\n idx = result.length - 3\n result = \"$\" + result[0,idx] + \",\" + result[(idx)..(idx + 2)]\n elsif result.length >= 7 && result.length <=9\n idx = result.length - 6\n result = \"$\" + result[0,idx] + \",\" + result[(idx)..(idx + 2)] + \",\" + \n result[(idx + 3)..(idx + 5)]\n end\n return result\n end",
"def price_pretty\n number_to_currency(price_dollars)\n end",
"def price_as_string\n return \"$\" + '%.2f' % @price\n end",
"def currency_format string\n while string.sub!(/(\\d+)(\\d\\d\\d)/,'\\1,\\2'); end\n string\n end",
"def currency_format(number, currency = \"$\")\n prefix = number >= 0 ? currency : \"-#{currency}\"\n moneys = number.abs.to_s\n while moneys.match(/(\\d+)(\\d\\d\\d)/)\n moneys.to_s.gsub!(/(\\d+)(\\d\\d\\d)/, \"\\\\1,\\\\2\")\n end\n \"#{prefix}#{moneys}\"\nend",
"def indivisible_number_to_currency(number, options = {})\n return unless number.present?\n r = number_to_currency(number, options).gsub(' ', ' ')\n r ? r.html_safe : \"\"\n end",
"def to_currency(value)\n go = (value/1000000000).floor\n mo = ((value - go*1000000000)/1000000).floor\n ko = ((value - go*1000000000 - mo*1000000)/1000).floor\n o = (value - go*1000000000 - mo*1000000 - ko*1000).floor\n\n o = \"00.#{o}\" if ( (o.length) == 1 )\n o = \"0.#{o}\" if ( (o.length) == 2 )\n\n result_string = o\n result_string = \"#{ko}...#{result_string}\" if ( ko != 0 )\n result_string = \"#{mo}...#{result_string}\" if ( mo != 0 )\n result_string = \"#{go}...#{result_string}\" if ( go != 0 )\n\n result_string = @currency.result_strin\n return(result_string)\n end",
"def format_price price\n \"$#{'%.2f' % price}\"\n end",
"def with_currency(klass, amount = :amount, options = {})\n options = {:precision => 2}.merge(options)\n \"#{number_to_currency klass.send(amount), options} <span class='labelz' title='#{klass.currency_name}'>#{klass.currency_code}</span>\".html_safe\n end",
"def currency_as_string\n self.currency.to_s\n end",
"def currency_as_string\n self.currency.to_s\n end",
"def numberOptStr\n nil\n end",
"def inspect\n\n \"#{'%.02f' % (@amount_bigdecimal)} #{@currency}\"\n\n end",
"def price_as_string\n return \"$\"+format(\"%.2f\", @price)\n end",
"def price_format(whose)\n #Helper method\n def cent_string(cents)\n cents = cents.to_i\n if cents == 0\n return \"Free\"\n elsif cents == -1\n return \"Sold Out\"\n end\n output = (cents % 100).to_s\n if output.length != 2\n output += '0'\n end\n output = \"$\" + (cents / 100).floor.to_s + \".\" + output\n return output\n end\n\n if whose == 'full'\n low = cent_string(full_price_range_low)\n high = cent_string(full_price_range_high)\n else\n low = cent_string(our_price_range_low)\n high = cent_string(our_price_range_high)\n end\n output = low\n if high != low\n output = \"#{output} - #{high}\"\n end\n return output\n end",
"def payment_format(*options)\n @is_ach_payment ? 'CCP' : ''\n end",
"def ntc(val = nil, options = {})\n #number_to_currency(val.to_f, options)\n number_with_delimiter(val.to_f, t(\"number.format\").merge(options))\n end",
"def print_money(value)\n number_with_delimiter( value , :delimiter => \",\")\n end",
"def price_as_string\n \"$#{sprintf('%.2f', price)}\"\n format(\"$%.2f\",price)\nend",
"def price_as_string\n\t sprintf(\"$%.2f\",price)\n\n end",
"def price_as_string()\n @price = '%.2f' % (@price)\n return \"$\"+@price.to_s \n end",
"def inspect\n \"#{@amount} #{@currency}\" if @amount && @currency\n end",
"def convert hash\n currency = detect_currency hash[:currency]\n return nil if currency == :not_expected\n\n amount = (hash[:amount]).delete(' _').sub(',', '.').to_f\n usdrub_rate = (usd_base_json['rates']['RUB']).to_f\n usdeur_rate = (usd_base_json['rates']['EUR']).to_f\n usdcad_rate = (usd_base_json['rates']['CAD']).to_f\n\n rate = usdrub_rate\n rate = usdrub_rate / usdeur_rate if currency == :EUR\n rate = usdrub_rate / usdcad_rate if currency == :CAD\n\n change_currency = currency != :RUB ? :RUB : :USD\n result = change_currency == :RUB ? (amount * rate) : (amount / rate)\n\n \"#{space_in result.round(2)} #{change_currency}\"\nend",
"def invoice options={}\n puts options[:company]\n puts options[:total]\n puts options[:something_else]\nend",
"def invoice options={}\n puts options[:company]\n puts options[:total]\n puts options[:something_else]\nend",
"def currency_of(method, options={})\n number = @record.send(method) || 0\n if number < 0\n \"<span attr=\\\"#{@object_name}[#{method}]\\\" value=\\\"#{h(number)}\\\" class=\\\"#{options[:class]} negative\\\">($#{h(number_to_currency -number, :unit=>\"\")})</span>\".html_safe\n else\n \"<span attr=\\\"#{@object_name}[#{method}]\\\" value=\\\"#{h(number)}\\\" class=\\\"#{options[:class]}\\\">$#{h(number_to_currency number, :unit=>\"\")}</span>\".html_safe\n end\n end",
"def price_as_string\n\t\tformat(\"$%2.2f\", @price)\n\tend",
"def price_as_string\n format(\"$%.2f\", @price)\nend",
"def price_as_string\n sprintf(\"$%2.2f\", @price)\n end",
"def price_as_string \n \"$\" + ('%.2f' % @price).to_s\n end",
"def currency; end",
"def currency; end",
"def currency_as_string=(val)\n @currency = Currency.wrap(val)\n end",
"def currency_as_string=(val)\n @currency = Currency.wrap(val)\n end",
"def currency_as_string=(val)\n @currency = Currency.wrap(val)\n end",
"def currency_as_string=(val)\n @currency = Currency.wrap(val)\n end",
"def currency options = {}\n remove_currency_columns\n column :currency, :string, options\n end",
"def show_quantity(options = {})\n quantity_packed.to_s + 'boxes + ' + quantity_unpacked.to_s + 'pcs available'\n end",
"def get_USD (num_string)\n if num_string == nil || num_string.to_i == 0\n return num_string\n end\n\n num_string = num_string.to_s.split(\"\")\n\n usd = [\"$\"]\n\n num_string.each_with_index do |num, index|\n if index == ((num_string.length) -1)\n usd << \"#{num}.00\"\n elsif index != 0 && index % 3 == 0\n usd << \",#{num}\"\n else\n usd << num.to_s\n end\n end\n return usd.join(\"\")\n end",
"def price_display\n 'INR ' + price.to_s\n end",
"def to_currency(num)\n format(\"$%.2f\",num)\nend",
"def currency\n \"USD\"\n end",
"def ot_currency_code\n end",
"def number_to_currency_without_double_zeros(number, options = {})\n formatted_number = number_to_currency(number, options)\n\n defaults = I18n.translate(:'number.format', :locale => options[:locale], :default => {})\n precision_defaults = I18n.translate(:'number.precision.format', :locale => options[:locale], :default => {})\n defaults = defaults.merge(precision_defaults)\n options = options.reverse_merge(defaults)\n escaped_separator = Regexp.escape(options[:separator])\n formatted_number.to_s.sub(/#{escaped_separator}00/, '')\n end",
"def price_as_string\n format(\"$%.2f\", @price)\n end",
"def price_as_string\n format(\"$%.2f\", @price)\n end",
"def price_as_string\n return sprintf('$%.2f', @price)\n end",
"def price_as_string\n sprintf(\"$%.2f\", @price)\n end",
"def inspect\n \"#{\"%0.02f\" % @amount} #{@base_currency}\"\n end",
"def formated_value(valor)\n number_to_currency(valor,:unit => \"R$\",:separator => \",\",:delimiter => \".\")\n end",
"def formated_in_provided_currency(amount_cents, currency_code, no_cents_if_whole = false)\n Money.new(amount_cents, currency_code).format(:no_cents_if_whole => no_cents_if_whole)\n end",
"def price_display\n lookup = {\n 'cheap' => '$',\n 'affordable' => '$$',\n 'pricey' => '$$$',\n 'expensive' => '$$$$'\n }\n lookup[price] # return the dollar signs corresponding to this price enum value\n end",
"def number_to_currency(number, options = {})\n # Blend default options with localized currency options\n options.reverse_merge!(LocalizationSimplified::NumberHelper::CurrencyOptions)\n options[:order] ||= [:unit, :number]\n options = options.stringify_keys\n precision, unit, separator, delimiter = options.delete(\"precision\") { 2 }, options.delete(\"unit\") { \"$\" }, options.delete(\"separator\") { \".\" }, options.delete(\"delimiter\") { \",\" }\n separator = \"\" unless precision > 0\n\n #add leading space before trailing unit\n unit = \" \" + unit if options[\"order\"] == [:number, :unit]\n output = ''\n begin\n options[\"order\"].each do |param|\n case param\n when :unit\n output << unit\n when :number\n parts = number_with_precision(number, precision).split('.')\n output << number_with_delimiter(parts[0], delimiter) + separator + parts[1].to_s\n end\n end\n rescue\n output = number\n end\n output\n end",
"def inspect\n context = @solution.map {|k, v| \"#{k}: #{v}\"}.join(',')\n \"#<Twilio.Pricing.V2.NumberContext #{context}>\"\n end",
"def currency\n\t\t\"USD\"\n\tend",
"def to_s\n s = sprintf(\"%0.#{@currency.decimal_places}f\", amount)\n s.gsub(\".\", decimal_mark)\n end",
"def format_money(money)\n money_with_dots = money.reverse.scan(/.{3}|.+/).join(\".\").reverse\n \"$#{money_with_dots}\" \n end",
"def display_currency(amount)\n '$' + ('%.2f' % amount).chomp('.00')\n end",
"def money(m)\n \"#{m.format(symbol: false)} #{m.currency.to_s}\"\n end",
"def currency_code\n h.e_system_currency\n end",
"def amount_for_display(amt, opts={})\n if amt.abs < CUTOFF_FOR_BTC and not amt.zero?\n satoshi = amt * BigDecimal.new(\"100000000\")\n if opts[:no_html]\n \"#{satoshi.truncate} Satoshi\"\n else\n \"#{satoshi.truncate} \" +\n link_to(\"Satoshi\",\n \"https://en.bitcoin.it/wiki/Satoshi\",\n :target => '_blank')\n end\n else\n \"#{amt.to_s('F')} BTC\"\n end\n end",
"def currency\n 'INR'\n end",
"def currency_symbol\n Currency.new(currency).symbol\n end",
"def format(*rules)\n return self.class.zero if zero? && self.class.zero\n\n # This section included for compatiblity since format in this fork\n # uses a splatted array instead of a hash to accept parameters\n # Hashes are needed to pass multi-dimensional parameters such as :precison => 5\n # BEGIN compatibility block\n rules_hash = {}\n rules.each do |rule|\n if rule.is_a?(Hash)\n rule.each_key do |key|\n rules.push(key)\n rules_hash[key] = rule[key]\n end\n end\n end\n # END of compatibility block\n\n # flattening array to allow explicit passing of arrays\n rules = rules.flatten\n\n formatted =\n if rules.include?(:no_cents)\n \"$#{to_s(0)}\"\n elsif rules.include?(:precision)\n \"$#{to_s(rules_hash[:precision])}\"\n else\n \"$#{to_s(2)}\"\n end\n\n # BJM: Apply thousands_separator\n thousands_separator_value = ','\n decimal_separator = '.'\n regexp_decimal = Regexp.escape(decimal_separator)\n\n formatted_parts = formatted.split(decimal_separator)\n integer_part = formatted_parts.first\n decimal_part = formatted_parts.last unless rules.include?(:no_cents)\n\n integer_part.gsub!(/(\\d)(?=(?:\\d{3})+(?:[^\\d]{1}|$))/, \"\\\\1#{thousands_separator_value}\")\n\n formatted = \"#{integer_part}\"\n\n formatted += \"#{decimal_separator}#{decimal_part}\" unless rules.include?(:no_cents)\n\n # BJM: move negative outside ($-2.00 => -$2.00)\n formatted.gsub!('$-', '-$')\n\n # BJM: use parenthesis if requested and required\n if rules.include?(:parenthesize_negative) && formatted.gsub!('-$', '$')\n formatted = \"(#{formatted})\"\n end\n\n if rules.include?(:with_currency)\n formatted << \" \"\n formatted << '<span class=\"currency\">' if rules.include?(:html)\n formatted << currency\n formatted << '</span>' if rules.include?(:html)\n end\n \n formatted\n end",
"def value_formatted\n if @action == 'buy'\n \"-$#{@value}\"\n else\n \"+$#{@value}\"\n end\n end",
"def dollar amt\n #TOOD: need commas in the right places\n sprintf \"$%0.02f\", amt\nend",
"def display_amount\n self.symbol + self.to_s\n end",
"def to_s()\n result = nil\n \n if @number < 10\n result = WORD_DICT[@number]\n\n elsif number <= 99\n result = two_least_sig\n \n elsif number == 1000\n result = \"one thousand\"\n\n elsif number % 100 == 0\n result = hundreds_component\n\n elsif number <= 999\n result = \"#{hundreds_component} and #{two_least_sig}\"\n end\n\n return result\n end"
] |
[
"0.71907204",
"0.7063055",
"0.70190763",
"0.6985442",
"0.69077504",
"0.67169166",
"0.6700911",
"0.6589675",
"0.64248496",
"0.6295236",
"0.6284713",
"0.6274329",
"0.62716234",
"0.6267303",
"0.62597984",
"0.62457037",
"0.62457037",
"0.62248987",
"0.62122995",
"0.62122995",
"0.6203303",
"0.62018174",
"0.6194423",
"0.6190771",
"0.6185863",
"0.61479264",
"0.6130419",
"0.6102261",
"0.6093563",
"0.6089335",
"0.60848564",
"0.60832435",
"0.60827935",
"0.60798454",
"0.6056",
"0.6049917",
"0.6049235",
"0.60474503",
"0.6045579",
"0.6014012",
"0.601207",
"0.59985673",
"0.59985673",
"0.59912103",
"0.59904957",
"0.59898007",
"0.59772533",
"0.5949802",
"0.59444165",
"0.59258866",
"0.59224135",
"0.5917732",
"0.59136516",
"0.5908968",
"0.5905105",
"0.59047407",
"0.59047407",
"0.5899507",
"0.58993477",
"0.58920336",
"0.5888885",
"0.5885951",
"0.58847344",
"0.58847344",
"0.5883874",
"0.5883874",
"0.5883874",
"0.5883874",
"0.58825845",
"0.5875822",
"0.5875258",
"0.5871482",
"0.5871352",
"0.5851741",
"0.58481497",
"0.5838358",
"0.5825099",
"0.5825099",
"0.581287",
"0.5801654",
"0.5793918",
"0.579114",
"0.57873297",
"0.5769288",
"0.5767797",
"0.5757014",
"0.5750533",
"0.5742061",
"0.5737908",
"0.57299286",
"0.57258606",
"0.57255274",
"0.5723549",
"0.571378",
"0.571293",
"0.5712895",
"0.57106936",
"0.5700686",
"0.5694397",
"0.5691921"
] |
0.65858483
|
8
|
this will be useful if we want to `puts params` in the server log
|
def to_s
@params.to_s
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def output_debug(params)\n Rails.logger.debug(\"\\n\\n\\n\\n------------------------------------------------\\n\")\n Rails.logger.debug(params.inspect)\n Rails.logger.debug(\"\\n------------------------------------------------\\n\\n\\n\\n\")\n end",
"def log_request\n logger.info \"HTTP request received => #{request.fullpath} , params => #{params} \"\n end",
"def p(params)\n MyLogger.info params\nend",
"def collectd\n logger.info(params.inspect)\n end",
"def log_params\n params[:log]\n end",
"def log_request\n # REQUEST_LOG.info( {\n # time: Time.now.to_s,\n # ip: request.remote_ip,\n # path: request.path,\n # site: request.host,\n # user_agent: request.user_agent,\n # params: (request.request_parameters.blank? ? request.query_parameters : request.request_parameters),\n # device: sub_group_type,\n # referer_header: referer,\n # current_page_header: current_page,\n # landing_url_header: land_url,\n # visitor_id_header: request.env['HTTP_VISITOR_ID'],\n # session_id_header: request.env['HTTP_SESSION_ID'],\n # visitor_id: visitor_id,\n # session_id: session_id,\n # params: params\n # } )\n end",
"def request_log(request); end",
"def log_params()\n lparms = @parameters.clone if @parameters\n lparms = {} unless lparms\n lparms[:cur_host] = @host\n lparms[:cur_port] = @port\n lparms[:cur_login] = @login\n lparms[:cur_passcode] = @passcode\n lparms[:cur_ssl] = @ssl\n lparms[:cur_recondelay] = @reconnect_delay\n lparms[:cur_parseto] = @parse_timeout\n lparms[:cur_conattempts] = @connection_attempts\n lparms[:cur_failure] = @failure # To assist in debugging\n lparms[:openstat] = open?\n #\n lparms\n end",
"def log_request(req)\n message = [req.remote_ip, req.command, req.args.join(' ')].join(' ')\n log.info(message)\n end",
"def printparams\r\n return if @@params.empty?\r\n @@params.each {|key, value| puts \"#{key} : #{value}\" }\r\n end",
"def log_event(params)\n puts \"Log Details:\"\n puts \"<====================>\"\n puts \"Event Type: #{params['event']}\"\n puts \"Recepient: #{params['recipient']}\"\n puts \"City: #{params['city']}\"\n puts \"Country: #{params['country']}\"\n puts \"Client Type: #{params['client-type']}\"\n puts \"Client Name: #{params['client-name']}\"\n puts \"Device Type: #{params['device-type']}\"\n puts \"Client OS: #{params['client-os']}\"\n puts \"Url Clicked: #{params['url']}\" if params['event'] == \"clicked\"\n puts \"Logged at: #{Time.at(params['timestamp'].to_i).utc.to_datetime}\"\n puts \"<====================>\"\n end",
"def log_params\n params.require(:log).permit(:class_name, :method_name, :hash_parms)\n end",
"def __log(method, path, params, body, url, response, json, took, duration)\n logger.info \"#{method.to_s.upcase} #{url} \" +\n \"[status:#{response.status}, request:#{sprintf('%.3fs', duration)}, query:#{took}]\"\n logger.debug \"> #{__convert_to_json(body)}\" if body\n logger.debug \"< #{response.body}\"\n end",
"def log _args\n \"log _args;\" \n end",
"def print_parameters()\n @params.each do |clave, valor|\n #$LOG.debug \"The Parameter #{clave} have the value \" +valor.to_s\n puts \"#{clave} = #{valor} \"\n end\n end",
"def log_request_info(env, req_id)\n query_string = \"?#{env.url.query}\" if env.url.query\n size = env.body.respond_to?(:size) ? env.body.size : env.request_headers['Content-Length']\n info { \"{#{req_id}} [OUT] #{env.method} #{env.url.path}#{query_string} (#{size || 0})\" }\n end",
"def history_log_params\n end",
"def log(msg, meta = {})\n puts \"#{msg} --- #{meta}\"\nend",
"def log_event(event, params)\n end",
"def debugLog _args\n \"debugLog _args;\" \n end",
"def log_params\n params.permit(:macaddress, :secret_key, :log_file, :page)\n end",
"def log(*args); end",
"def append_info_to_payload(payload)\n super\n request_logging_context_data.each do |key, value|\n payload[key] = BlackSquareLoggingRails.format_value(value)\n end\n\n # Add request parameters to lograge output when the logger is in DEBUG mode\n if BlackSquareLoggingRails.enable_request_parameter_logging\n parameters = request.filtered_parameters.except(*ActionController::LogSubscriber::INTERNAL_PARAMS)\n payload[:request_params] = BlackSquareLoggingRails.format_value(parameters) if parameters.any?\n end\n end",
"def error_log_params\n params[:error_log]\n end",
"def zt_log *args\n if args.length == 0\n File.open(ZT_LOG_FILE, 'a') { |file_log| file_log.puts \"#{zt_timestamp} #{params[:controller]}##{params[:action]} - no arguments\"}\n else\n file_log = File.open(ZT_LOG_FILE, 'a') # Opens file\n file_log.puts \"#{zt_timestamp} #{params[:controller]}##{params[:action]}:\" # Writes controller#action\n\n # Writes all arguments to ...\n args.each_with_index do |arg, index|\n file_log.puts \"arg[#{index}]: #{arg.inspect}\" # ... zt.log\n puts \"arg[#{index}]: #{arg.inspect}\" # ... console\n# logger.debug \"arg[#{index}]: #{arg.inspect}\" # ... console & development.log\n end\n file_log.close #Closes file\n end\n end",
"def log(type, msg, meta=nil)\n post type, msg, meta\n end",
"def debug\n \tputs \"session is:\" + session.inspect\n\tputs \"params are:\" + params.inspect\n end",
"def log_params\n params.require(:log).permit(:msg)\n end",
"def log (msg, **kwargs) Log.write(msg, :info, kwargs) end",
"def log(params_hash = {})\n begin\n raise_error_unless_params_is_a_hash(params_hash)\n request.method = :get\n request.uri = \"_log#{querystring(params_hash)}\"\n Couchdbtools.execute(request)\n rescue Exception => exception\n exception.message\n end\n end",
"def print_parameters()\n @h.each do |clave, valor|\n \n $LOG.debug \"The Parameter #{clave} have the value \" +valor.to_s\n end\n end",
"def log(msg)\n Serv::Log.info(Time.now.to_s+': '+msg+\"\\n\")\n end",
"def log_request\n \"#{request.ip} - #{session[:login] ? session[:login].name : '-'} [#{Time.now.strftime('%d/%m/%Y:%H:%M:%S %z')}] \\\"#{request.request_method} #{request.path} HTTP\\\" #{response.status} #{response.content_length} #{timer.stop(request.object_id).round(3)}\"\n end",
"def log; end",
"def log; end",
"def log; end",
"def log; end",
"def log; end",
"def log; end",
"def log; end",
"def log; end",
"def log(path)\n case path\n when *Global.boring\n else\n Log.info(\"Dynamic request from #{request.ip}: #{request.request_uri}\")\n end\n end",
"def log(*args)\n\t\t\trouter.log(*args)\n\t\tend",
"def log_request_debug(env, req_id)\n debug { \"{#{req_id}} [OUT] #{env.body}\" }\n end",
"def user_log_params\n params[:user_log]\n end",
"def log_sql(query, params = {})\n if @debug\n message = \"#{colorize(\"[#{@name}]\", :cyan)} #{query.gsub(/\\s+/, \" \").strip}\"\n message = \"#{message} #{params.inspect}\" if params.any?\n log message\n end\n end",
"def log_params\n params.fetch(:log, {}).permit(\n :cat_id, :feed_id, :fed_at\n )\n end",
"def log(*args)\nend",
"def log(*args)\n puts *args\n end",
"def log(msg)\n puts msg if @verbose\n end",
"def log(msg)\n puts msg if @verbose\n end",
"def log(type='Log', text)\n puts \"[#{type}] #{text}\"\n submit_log(LOG_HOST, LOG_PORT, type, text)\nend",
"def log(arg1, arg2, *rest); end",
"def info(msg) log(6, msg); end",
"def grid_rest_log(method, url, rparams = {}, emsg = \"\")\n if current_namespace\n return unless GridRest.grid_config.namespaces[current_namespace]['logging']\n else\n return unless GridRest.grid_config['logging']\n end\n grid_rest_log_message(rparams.any? ? \"#{Time.now.to_s(:db)} #{method.to_s.upcase} #{url} with #{rparams.inspect} #{emsg}\" : \"#{Time.now.to_s(:db)} #{method.to_s.upcase} #{url} #{emsg}\")\n end",
"def log_params\n params.require(:log).permit(:date_of_session, :time_of_sesion, :details, :reference_code, :client_code, :iname)\n end",
"def log(params = nil)\n if @name_index\n @conf.insert(@name_index + @conf.length, \" \" + \"log \" + params.to_s + \"\\n\")\n else\n puts \"no #{@proxy_type} name assigned\"\n return false\n end\n end",
"def append_info_to_payload(payload)\n super\n payload[\"params\"] = request.params\n end",
"def append_info_to_payload(payload)\n super\n payload[\"params\"] = request.params\n end",
"def log(msg)\n puts msg\n end",
"def log(*_args)\n end",
"def debug_params\n params.require(:debug).permit(:log, :user)\n end",
"def log\n end",
"def access_logger\n Rails.application.config.another_logger.info(\"#{request.method} '#{request.path}' #{request.version} from: #{request.remote_ip}\")\n end",
"def debug_log( arg )\r\n print('DEBUG: ')\r\n puts (arg)\r\nend",
"def info_msg(msg)\n @log.puts(msg)\n puts msg\nend",
"def log_request\n ServerRequestLog.create! default_log_hash\n end",
"def log_request_begin(logger, env)\n # Assuming remote addresses are IPv4, make them all align to the same width\n remote_addr = env['HTTP_X_FORWARDED_FOR'] || env[\"REMOTE_ADDR\"] || \"-\"\n remote_addr = remote_addr.ljust(15)\n\n # Log the fact that a query string was present, but do not log its contents\n # because it may have sensitive data.\n if (query = env[\"QUERY_STRING\"]) && !query.empty?\n query_info = '?...'\n else\n query_info = ''\n end\n\n # Session\n if env['global_session']\n cookie = env['global_session']\n info = [ env['global_session'].id,\n cookie.keys.map{|k| %{\"#{k}\"=>\"#{cookie[k]}\"} }.join(', ') ]\n sess = %Q{Session ID: %s Session Data: {%s}} % info\n else\n sess = \"\"\n end\n\n shard_info = 'Shard: ' + (env['HTTP_X_SHARD'] || 'default').to_s + ';'\n\n params = [\n env[\"REQUEST_METHOD\"],\n env[\"PATH_INFO\"],\n query_info,\n remote_addr,\n sess,\n shard_info,\n env[\"rack.request_uuid\"] || ''\n ]\n\n logger.info %Q{Processing %s \"%s%s\" (for %s) %s %s Request ID: %s} % params\n end",
"def log(msg)\n puts\n puts msg\nend",
"def params() request.params end",
"def logger_info\n {\n :url => url,\n :body => body.inspect\n }\n end",
"def log_http_call(payload); end",
"def log_http_call(payload); end",
"def create_log(param); end",
"def log_requests(which = T.unsafe(nil)); end",
"def log_params\n params.require(:log).permit(:uniqid, :contact_id, :log_type, :time, :duration, :device_id, :device_imei, :contact_number)\n end",
"def debug(message) ; @log.debug(message) ; end",
"def log(message)\n puts message\n end",
"def debug_begin_request\n str = <<END\n ~ Start: #{Time.now}\n ~ Params: #{params.inspect}\n ~ Session: #{session.instance_variable_get(:@data).inspect}\nEND\n @__start_action_time = Time.now\n puts str\n end",
"def log_dispatch(method, args=[])\n\t\t\tmeth_str = self.class.to_s + \"#\" + method.to_s\n\t\t\tmeth_str += \" #{args.inspect}\" unless args.empty?\n\t\t\tlog \"Dispatching to: #{meth_str}\"\n\t\tend",
"def log_params\n params.require(:log).permit(:user_id, :action, :content)\n end",
"def info_request(*args)\n info args.join(' ')\n end",
"def log_http_request(request)\n log :info, \"Starting request: #{request.method} #{request.path}\"\n\n return unless log_debug?\n\n log :debug, \" body : #{request.body}\"\n log :debug, \" headers :\"\n request.each_header do |name, value|\n log :debug, \" #{name}: #{value}\"\n end\n end",
"def debug(msg) log(7, msg); end",
"def verbosity(conn, method, *args)\n return unless noop || verbose\n log format('uri: %s %s', method.upcase, conn.url_prefix)\n\n return unless args.last && !args.last.empty?\n\n log method == :get ? \"params: #{args.last}\" : \"body: #{args.last}\"\n end",
"def p(arg)\n NSLog arg.inspect\n end",
"def logs\n\n end",
"def log_params\n p = params.require(:log).permit(:type, :team_id, :time, :user_id, :client, :log_type, :deleted, :point, :data, :gen)\n if !p.has_key?(:type)\n # add the type if not present; this can be from an old app\n p.merge!({ type: 'TeamLog' })\n else\n p\n end\n end",
"def write( message )\n\t\t\tApache.request.server.log_debug( message )\n\t\tend",
"def log(message); logger.info(message); end",
"def info(msg); @logger.info(msg); end",
"def _roda_after_90__common_logger(result)\n return unless result && result[0] && result[1]\n\n env = @_request.env\n\n qs = env[\"QUERY_STRING\"]\n query_string = \"?#{ qs }\" unless qs.empty?\n\n length = result[1][\"Content-Length\"]\n length = \"\" if length == \"0\"\n\n LOGGER.request \"#{ env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR'] || '-' } - \\\"#{ env['REQUEST_METHOD'] } #{ env['SCRIPT_NAME'] }#{ env['PATH_INFO'] }#{ query_string } #{ env['HTTP_VERSION'] }\\\" #{ result[0] } #{ length }\\n\"\n end",
"def encode_params(log_msg)\n params_patterns = \"(#{ENCODE_PARAMS.join('|')})=\\\\w+\"\n log_msg.gsub(Regexp.new(params_patterns)) { |match| hide_value(match).to_s }\n end",
"def log_metric_params\n params.fetch(:log_metric, {})\n end",
"def action_log_params\n params.require(:action_log).permit(:user_id, :target_user, :do_user, :infomation, :log_type, :description)\n end",
"def echo(params)\n params\n end",
"def log(s)\n puts \"[Debug]: #{s}\"\nend",
"def log(s)\n puts \"[Debug]: #{s}\"\nend",
"def logs\n end",
"def params\n '(%s)' % @format\n end",
"def log_load_time_params\n params.fetch(:log_load_time, {})\n end"
] |
[
"0.7539688",
"0.7500098",
"0.7247633",
"0.701044",
"0.70040363",
"0.67842156",
"0.676317",
"0.666582",
"0.66440433",
"0.6626347",
"0.65786785",
"0.6577528",
"0.65625983",
"0.65605503",
"0.65155727",
"0.64918655",
"0.6450838",
"0.6412487",
"0.64084923",
"0.63752234",
"0.6375087",
"0.634494",
"0.6340035",
"0.6331917",
"0.6329033",
"0.63199836",
"0.6315968",
"0.62599415",
"0.62488455",
"0.6240615",
"0.62342626",
"0.6213699",
"0.61992323",
"0.61938155",
"0.61938155",
"0.61938155",
"0.61938155",
"0.61938155",
"0.61938155",
"0.61938155",
"0.61938155",
"0.61929214",
"0.619069",
"0.6166918",
"0.61573637",
"0.61493194",
"0.6148963",
"0.61351997",
"0.6126866",
"0.61214876",
"0.61214876",
"0.6114758",
"0.61046547",
"0.6099209",
"0.60927546",
"0.609229",
"0.6088552",
"0.6077029",
"0.6077029",
"0.6065389",
"0.60283506",
"0.60272247",
"0.60258865",
"0.6025327",
"0.6022987",
"0.6018448",
"0.6011258",
"0.5987087",
"0.5986829",
"0.59855855",
"0.5978229",
"0.5977926",
"0.5977926",
"0.5970769",
"0.5966198",
"0.5953351",
"0.59122163",
"0.5910711",
"0.5904477",
"0.5895452",
"0.5894906",
"0.5894404",
"0.5894264",
"0.5891763",
"0.5890854",
"0.58887887",
"0.58878434",
"0.58751774",
"0.58745337",
"0.58629864",
"0.58620346",
"0.5861856",
"0.58510214",
"0.5850296",
"0.58476645",
"0.5841325",
"0.5838876",
"0.5838876",
"0.58037144",
"0.5801651",
"0.57998806"
] |
0.0
|
-1
|
this should return an array user[address][street] should return ['user', 'address', 'street']
|
def parse_key(key)
key.split(/\]\[|\[|\]/)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def get_user_data(users, username)\n user_array = []\n users.each do |user|\n if user['username'] == username\n user_array << user['name']\n user_array << user['username']\n user_array << user['password']\n user_array << user['admin']\n end\n end\n return user_array\nend",
"def extract_user_emails(user_fields, client)\n user_emails = []\n user_fields.each_index do |row|\n user_emails.push(user_fields[row][0])\n end\n user_emails\nend",
"def user_keys\n all_keys = params[:user].keys\n all_keys.collect do |key|\n next if key == \"addresses_attributes\"\n key\n end\n end",
"def address_keys\n address_attr = params[:user][\"addresses_attributes\"].values\n address_attr[0].keys\n end",
"def addresses(tenantArr)\n tenantArr.each do |tenant|\n #puts tenant[:name]\n end\n end",
"def get_name_and_location\n @top_ten.each do |user|\n user_details = self.class.get(\"/users/#{user[0]}\").parsed_response\n user << user_details[\"name\"]\n user << user_details[\"location\"]\n end\n end",
"def addresses(aptArr)\n aptArr.each do |apt|\n #puts apt[:address]\n end\n end",
"def getTaxAddress property\n\t\tarr = []\n\t\taddray = property[:taxAddr].split\n\t\tarr << (addray[0...-3].join \" \")\n\t\tarr << addray[-3]\n\t\tarr << addray[-2]\n\t\tarr << addray[-1]\n\t\tarr << property[:owns]\n\t\tarr << property[:owner]\n\t\tarr\n\tend",
"def find_user (map)\n user = []\n for i in 0..map.length-1\n for j in 0..map.length-1\n if map[i][j] == \" U \"\n user = [i,j]\n end\n end\n end\n user\n end",
"def users\n @users.each_key.to_a\n end",
"def get_users_a\n\n return [] if self.users.nil? or self.users.empty?\n\n array = self.users.split('|')\n array.compact!\n array.delete('')\n\n return array\n end",
"def get_biz_names_addresses_coordinates\n @request_businesses.shift(2).map{|business|{name: business[\"name\"], address: business[\"vicinity\"], latitude: business[\"geometry\"][\"location\"][\"lat\"], longitude: business[\"geometry\"][\"location\"][\"lng\"]}}\n end",
"def get_users\n username_array = []\n con = get_connection()\n usernames = con.exec \"SELECT username FROM hashes\"\n usernames.each do |name|\n username_array[username_array.length] = name['username']\n end\n return username_array\nend",
"def return_this(user_id)\n return_this = []\n converts_result_hash_into_array(user_id).each do |i|\n return_this << (i[0] + \" -- \" + i[1])\n end\nreturn return_this\nend",
"def users\n result_hash['usr']\n end",
"def get_array(element, path='.')\n return unless element\n \n result = element/path\n if (result.is_a? Nokogiri::XML::NodeSet) || (result.is_a? Array)\n result.collect { |item| self.get(item) }\n else\n [self.get(result)]\n end\n end",
"def build_hash(emails, first_names, last_names)\n deputies_array = []\n\n emails.each_with_index do |email, index|\n deputy_hash = {}\n deputy_hash['first_name'] = first_names[index]\n deputy_hash['last_name'] = last_names[index]\n deputy_hash['email'] = email\n deputies_array << deputy_hash\n end\n\n deputies_array\nend",
"def keys(key)\n Array(@nesting) + Array(key)\n end",
"def extract_user_object_attributes(users)\n arr = users.inject([]) do |a, user|\n u = HashWithIndifferentAccess.new(user)\n a << u.slice(*USER_ATTRIBUTES)\n end\n\n return arr\n end",
"def user_ids \n @user_ids ||= input[\"users\"].map{|user| user[\"id\"]}\nend",
"def get_user_bracket(url)\n\n\nend",
"def dot_key_array\n return ['label', 'label and hint','message','message error', 'message info','message success','message warning','model','model and menu','action', 'lookup']\n end",
"def get_users input\n\t\t@users[input]\n\tend",
"def user_data_as_array(key)\n val = ec2_user_data(key)\n if !val || val.empty?\n val = []\n elsif !val.is_a?(Array)\n val = [val]\n end\n\n val\n end",
"def show_address_fields(user, company)\n\n all_fields = [ { name: 'street_address', label: 'street', method: nil },\n { name: 'post_code', label: 'post_code', method: nil },\n { name: 'city', label: 'city', method: nil },\n { name: 'kommun', label: 'kommun', method: 'name' },\n { name: 'region', label: 'region', method: 'name' } ]\n\n if user.admin? || user.is_in_company_numbered?(company.company_number)\n return all_fields, true\n else\n start_index = all_fields.find_index do |field|\n field[:name] == company.address_visibility\n end\n\n if start_index\n return all_fields[start_index..4], false\n else\n return nil, false\n end\n end\n end",
"def profile_info_items(user)\n occupation = [\"Occupation\", user.occupation]\n company = [\"Company\", user.company]\n location = [\"Location\", user.location]\n birthday = [\"Birthday\", user.birthday? ? user.birthday.strftime(\"%m/%d/%Y\") : nil]\n [ occupation, company, location, birthday ]\n end",
"def users\n recipes.map {|recipe| recipe.user}\n end",
"def retrieveaddressnameskey(fileonedata)\n arr = Array.new\n fileonedata.each_line.with_index do |single_line, index|\n arr.push(single_line.split[0]) if (single_line.split[5] && index>20)\n end\n return arr\n end",
"def users\n return @users_array\n \tend",
"def address_ret(res_name)\n # id = res_name[:id]\n separate\n name = res_name[:name]\n address1 = res_name[:location][:city]\n address2 = res_name[:location][:state]\n return \"The location of #{name} is #{address1}, #{address2}\"\nend",
"def get_names(instructors)\n instructors.map do |instructor|\n instructor[:name]\n end\nend",
"def full_address_array\n [name, address1, address2, city_state_zip].compact\n end",
"def full_address_array\n [name, address1, address2, city_state_zip].compact\n end",
"def users\n @circle.keySet.to_a\n end",
"def get_names(instructors)\n # map will return a new array with the same number of elements\n instructors.map do |instructor_hash|\n # we want to return JUST the name\n instructor_hash[:name]\n end\nend",
"def parse_user_info(node)\n return nil if node.nil?\n {}.tap do |hash|\n node.children.each do |e|\n unless e.kind_of?(Nokogiri::XML::Text) || e.name == 'proxies'\n # There are no child elements\n if e.element_children.count == 0\n if hash.has_key?(e.name)\n hash[e.name] = [hash[e.name]] if hash[e.name].is_a? String\n hash[e.name] << e.content\n else\n hash[e.name] = e.content\n end\n elsif e.element_children.count\n # JASIG style extra attributes\n if e.name == 'attributes'\n hash.merge!(parse_user_info(e))\n else\n hash[e.name] = [] if hash[e.name].nil?\n hash[e.name] = [hash[e.name]] if hash[e.name].is_a? String\n hash[e.name].push(parse_user_info(e))\n end\n end\n end\n end\n end\n end",
"def get_nicknames_and_names(users)\n list = []\n users.each do |user|\n list.push({ :nickname => get_nickname(user), :name => get_name(user) })\n end\n \n return list\n end",
"def _get_array(sp, key)\n return self[key] if sp.length == 0\n\n if key.is_a?(Range)\n res = []\n self[key].each do |k|\n next unless k.structured?\n res << k.rh_get(sp) if k.rh_exist?(sp)\n end\n res\n else\n self[key].rh_get(sp) if self[key].structured?\n end\n end",
"def readinformation student\n [student[:firstname], student[:lastname], student[:course]]\nend",
"def build_addresses(v)\n # only create on address\n if v.kind_of? Hash\n return [Address.new(v)]\n # create multiple addresses\n elsif v.kind_of? Array\n # todo: multiple addresses\n end\n end",
"def hash_flatten prefix, value\n if value.is_a? Hash\n value.flat_map do |k, v|\n key = prefix.empty? ? k : [prefix, k].join('.')\n hash_flatten(key, v)\n end\n else\n [[prefix, value]]\n end\nend",
"def context_customer_emails(context)\n context = JSON.parse(context)\n customer_emails = context['context']['environment']['customer']['emailAddresses']\n customer_emails = customer_emails.map {|x| x[\"value\"]}\nend",
"def get_townhall_email(townhall_url)\r\n page = get_page(townhall_url)\r\n email = page.xpath('//*[contains(text(), \"@\")]').text\r\n town_name = page.xpath('//*[contains(text(), \"Adresse mairie de\")]').text.split #nom de ville\r\n email_array_one_hash = [{town_name[3] => email}] #nom\r\n return email_array_one_hash\r\nend",
"def all_users\n return [] if @json_data['users'].nil?\n @json_data['users'].collect { |user| [user['first'], user['last']].join(' ') }\n end",
"def names_mails\n mail_array = depute_mail\n names_array = names\n a = []\n\n names_array.each_with_index do |x, y|\n a << {x => (mail_array) [y]}\n end\n \n puts a\n return a\nend",
"def team_names\n # team_array = []\n # team_array.push(game_hash[:home][:team_name])\n # team_array.push(game_hash[:away][:team_name])\n # team_array\n game_hash.map do |location, team_data|\n team_data[:team_name]\n end\nend",
"def address_array(visibility_limit = visibility)\n return [] if visibility_limit == self.class.no_visibility\n\n start_index = self.class.visibility_items.index { |viz_item| viz_item == visibility_limit }\n return [] unless start_index\n\n viz_items_length = self.class.visibility_items.length\n\n # Create the array with the actual values of the address.\n # Add in the kommun name if there is one for the address.\n if kommun\n ary = [street_address, post_code, city, kommun.name,\n sverige_if_nil][start_index..viz_items_length]\n else\n ary = [street_address, post_code, city,\n sverige_if_nil][start_index..(viz_items_length - 1)]\n end\n ary.delete_if { |f| f.blank? }\n end",
"def user\n {\n id: object.user.id,\n email: object.user.email,\n birthday: object.user.birthday,\n first_name: object.user.first_name,\n middle_name: object.user.middle_name,\n last_name: object.user.last_name,\n phone: object.user.phone,\n gender: object.user.gender,\n neighborships: object.user.neighborships\n }\n end",
"def get_contact_info_array\n rtn = []\n rtn << get_attr(:name)\n rtn << [:provided_by, self.provider.name] # Special case, as the symbol doesn't match the attribute\n rtn << get_attr(:phone)\n rtn << get_attr(:email)\n rtn << get_attr(:url)\n end",
"def get_user_collection_fields(username)\n query_and_build \"users/#{username}/collection/fields\"\n end",
"def users\n self.triples.map(&:first)\n end",
"def index\n @user_addresses = current_user.user_addresses\n end",
"def joinData(arr)\n return data = {\"rusr\" => arr[0][1..-1].split(\"!\")[0], \"raddress\" => arr[0].split(\"!\")[1], \"type\" => arr[1], \"where\" => arr[2][1..-1]}\n end",
"def getHash(restid)\n # get all ordered items of users who ordered in restaurant \"restid\"\n userItems=OrderMng.getAllUsersItemsByRestID(restid)\n # userItems=Hash[userItems.map.with_index { |value, index| [index, value] }]\n return userItems\nend",
"def get_target_users\n\n users = []\n\n self.get_orders.each do |user_hash|\n\n user_ids = user_hash.keys\n\n users = users + user_ids unless user_ids.nil?\n end\n\n users.compact!\n\n return users\n end",
"def usernames\n @attributes[:usernames]\n end",
"def usernames\n @attributes[:usernames]\n end",
"def curator_list\n users.map(&:email)\n end",
"def [](user_name)\n all[user_name]\n end",
"def user_data_from_results(res, username, key)\n users = res['users']\n users.each do |user|\n return user[key] if user['name'] == username\n end\n nil\n end",
"def parse_user search\n Hash[*search.split(',').map{|pair| pair.split('=').values_at(0..1)}.flatten]['uid']\n end",
"def index\n @users_and_address = {}\n @users.each do |user|\n @users_and_address[user] = user.has_role?(:doctor) ? Address.business_for(user) : Address.home_for(user)\n end\n end",
"def players\n # players_array = []\n # iterating through game hash and returning a list of all my players\n game_hash.map do |key, value|\n value[:players]\n end.flatten\n\nend",
"def get_key_from(field)\n return [] if Chef::Config[:solo] && !chef_solo_search_installed?\n return [] unless Chef::DataBag.list.key?('users')\n search('users', \"#{field}:*\").map do |v| # ~FC003 ignore footcritic violation\n Chef::Log.info \"ssh_server: installing ssh-keys for root access of user #{v['id']}\"\n v[field]\n end.flatten\nend",
"def addresses(tenantArr)\n tenantArr.each do |tenant|\n if tenant[:age] > 44\n #puts tenant[:age]\n end\n end\n end",
"def email_addresses_with_details(only_validated = false)\n\t\t# {'email@address'=>{:name=>'member name'},...}\n\t\t{}\n\tend",
"def get_people(detail_page)\n first_table = detail_page.search('div#ctl00_MainBodyContent_group_17 table.ContentPanel')\n people_array = [] \n if first_table\n list_tr = first_table.search('tr')\n for i in 1..list_tr.length-1\n list_td = list_tr[i].search('td')\n people_obj = {}\n people_obj[:role] = clean_whitespace(list_td[0].inner_text)\n people_obj[:name] = clean_whitespace(list_td[1].inner_text)\n people_obj[:address] = clean_whitespace(list_td[2].inner_text)\n \n people_array << people_obj\n end\n else\n return \"\"\n end\n return people_array\nend",
"def get_people(detail_page)\n first_table = detail_page.search('div#ctl00_MainBodyContent_group_17 table.ContentPanel')\n people_array = [] \n if first_table\n list_tr = first_table.search('tr')\n for i in 1..list_tr.length-1\n list_td = list_tr[i].search('td')\n people_obj = {}\n people_obj[:role] = clean_whitespace(list_td[0].inner_text)\n people_obj[:name] = clean_whitespace(list_td[1].inner_text)\n people_obj[:address] = clean_whitespace(list_td[2].inner_text)\n \n people_array << people_obj\n end\n else\n return \"\"\n end\n return people_array\nend",
"def get_townhall_email(townhall_url)\n\tpage = Nokogiri::HTML(open(townhall_url)) \n\temail_array = []\n\n\temail = page.xpath('//*[contains(text(), \"@\")]').text\n town = page.xpath('//*[contains(text(), \"Adresse mairie de\")]').text.split \n# On divise la string pour pouvoir récupérer uniquement le nom de la ville\n\n email_array << {town[3] => email} \n# On indique la position du nom de la ville dans la string pour la récupérer\n\tputs email_array\n\treturn email_array\nend",
"def users\n user_arr = []\n accounts.each do |s|\n user_arr << User.find(s.user.id)\n end\n user_arr\n end",
"def filtered_user(raw_user)\n if raw_user['checkins'] && raw_user. checkins.items.count > 0\n recentCheckin = raw_user.checkins.items.first.venue.location\n else\n recentCheckin = {'lat' => nil, 'lng' => nil}\n end\n result = {\n 'id' => raw_user['id'],\n 'firstName' => (raw_user['firstName'] || \"\").gsub(/[^\\u0000-\\uFFFF]/, ''),\n 'lastName' => (raw_user['lastName'] || \"\").gsub(/[^\\u0000-\\uFFFF]/, ''),\n 'photo' => raw_user['photo'].to_hash,\n 'homeCity' => (raw_user['homeCity'] || \"\").gsub(/[^\\u0000-\\uFFFF]/, ''),\n 'superuser' => raw_user['superuser'],\n 'checkins' => {\n 'items' => [\n {\n 'venue' => {\n 'location' => {\n 'lat' => recentCheckin['lat'],\n 'lng' => recentCheckin['lng']\n }\n }\n }\n ]\n }\n }\n end",
"def allergens\n users.map do |user_ob|\n #binding.pry\n user_ob.allergens.each do |allergen_ob|\n #binding.pry\n allergen_ob\n end\n end.flatten\nend",
"def movies(user)\n\t\treturn @user_info[user].keys\t\n\tend",
"def extract_name(students)\n student_names = []\n students.each do |student|\n student_names.push(student[:name])\n end\n return student_names\nend",
"def get_recursive_array_from_params(params)\n return params if !params.kind_of?(Hash)\n resp = []\n params.each do |k, v|\n rec_ar = get_recursive_array_from_params(v)\n if rec_ar.kind_of?(Array)\n rec_ar.each do |r|\n if (r =~ /\\]/).nil?\n resp << \"#{k}[#{r.gsub('=', ']=')}\"\n else\n temp_string = r[(r =~ /\\[/) + 1, r.length]\n resp << \"#{k}[#{r[0, (r =~ /\\[/)]}][#{temp_string}\"\n end\n end\n else\n resp << \"#{k}=#{rec_ar}\"\n end\n end\n resp\n end",
"def registered_usr\n name_arry =[ \"david\", \"haggai\", \"mark\"]\n return name_arry\n end",
"def passwords\n @users.each_value.to_a\n end",
"def expect_user_addresses(user)\n user.reload\n expect_selected(user.bill_address, :user, :bill)\n expect_selected(user.ship_address, :user, :ship)\n\n expect_list_addresses(user.addresses)\n end",
"def value\n expand( address ).map { |ar| ar.map { |addr| data[ addr ] } }\n end",
"def keys\n [:name, :username, :email, ]\n end",
"def list_of_directors(source)\nrow_index = 0\narray =[]\nwhile row_index < source.length\n array << source[row_index][:name]\n row_index += 1\nend\narray\nend",
"def getSlices\n broker_url = APP_CONFIG['broker_ip'] + ':' + APP_CONFIG['broker_port'].to_s\n result = HTTParty.get(broker_url + \"/resources/users?name=\"+current_user.name, :verify => false)\n user_slices = []\n if result.header.code == '200'\n temp = JSON.parse(result.body) \n user_data = temp[\"resource_response\"][\"resources\"]\n user_data.each do |element|\n element[\"projects\"].each do |slice|\n user_slices << slice[\"account\"][\"name\"]\n end\n end \n else\n temp = JSON.parse(result.body)\n if temp[\"exception\"][\"reason\"] == \"No resources matching the request.\"\n flash[:danger] = \"No resources matching the request. Please create a slice\"\n else\n flash[:danger] = \"Something went wrong !\"\n end\n end\n\n return user_slices\n end",
"def user_array(user_data, game_data, index)\n\t\tis_button = game_data['state']['button'] == index\n\t\tis_active = game_data['state']['acting_player']['id'] == user_data['id']\n\t\tin_hand = game_data['state']['players_in_hand'].include?(user_data['id'])\n\t\tbet = game_data['state']['player_bets'][user_data['id'].to_s]\n\t\tall_in = user_data['bankroll'] == 0\n\t\tar = []\n\t\tar << \"#######\"\n\t\tar << \"##{user_data['name'][0,5].center(5)}#\"\n\t\tar << (is_button ? \"# B #\" : \"# #\")\n\t\tar << (all_in ? \"#ALLIN#\" : (is_active ? \"# Act #\" : \"#######\"))\n\t\tar << \"# Bet #\"\n\t\tar << (in_hand ? \"##{bet.to_s.center(5)}#\" : \"# Fold#\")\n\t\tar << \"#Stack#\"\n\t\tar << \"##{user_data['bankroll'].to_i.to_s.center(5)}#\"\n\t\tar << \"#######\"\n\tend",
"def student_data_hash\n\n # turn data into 2 Dim array containing arrays of eles where delimiter is colon :\n clean_user_account_data = ruby_class_user_accounts.map { |x| x.split(/:/) }\n\n # turn data into a hash using 2 arrays for keys and values\n keys = %w[user_name password uid gid gcos_field home_directory login_shell]\n final_array_of_hashes = []\n\n clean_user_account_data.each do |account_data|\n hash = Hash.new\n keys.each_with_index { |item, index| hash[item] = account_data[index] }\n final_array_of_hashes << hash\n end\n final_array_of_hashes\n end",
"def get_city_name(city_name)\n city_name.keys\nend",
"def addresses\n Array(@addresses)\n end",
"def generate_user_fields(user_params)\n return {:name => \"#{user_params[:firstname]} #{user_params[:lastname]}\",\n :email => user_params[:email],\n :password => user_params[:password],\n :college_id => College.find_by_name(user_params[:college]).id,\n :pending_school_id => user_params[:school],\n :pending_semester => user_params[:semester],\n :pending => 0,\n :profile => \"ambassador\" }\n end",
"def get_values_from_locations_and_prices_hash(user_id)\n process_search(user_id).values\nend",
"def addresses(tenantArr)\n tenantArr.each do |tenant|\n if tenant[:apartment_id] == 1\n #puts tenant[:apartment_id]\n end\n end\n end",
"def complete_name_list\n #User.select(:name).map{|user_record| user_record.name}\n end",
"def to_array\n [@name, @city]\n end",
"def transform_users_json_to_array(users, queue)\n users.each do |user|\n begin\n ident = user[\"identities\"].select { |identity|\n identity[\"provider\"] == \"auth0\"\n }.first\n row = [\n user[\"email\"],\n user[\"email_verified\"],\n user[\"given_name\"],\n user[\"family_name\"],\n (ident[\"user_id\"] if ident)\n ]\n queue << row\n rescue StandardError => ex\n @logger.warn ex\n end\n end\n end",
"def get_followers_from_tasks(tasks, array) #tasks == an array, array == an array\n tasks.each do |task|\n task[\"followers\"].each do |follower|\n #get user name based on user id\n user = JSON.parse(Typhoeus::Request.get(\"https://app.asana.com/api/1.0/users/\" + follower[\"id\"].to_s, userpwd: \"4tuQrdX.5djpapCXlKooicNrUgx0zbeY:\").body)\n array.push(user[\"data\"][\"name\"])\n end\n end\nend",
"def to_array_form(external_ref_path)\n # TODO: use regexp disjunction\n external_ref_path.gsub(/^node\\[/, '').gsub(/^service\\[/, '').gsub(/\\]$/, '').split('][')\n end",
"def get_array(key, values, level)\n content = ''\n content << \"#{key.to_s}[]=\"\n if values[0].is_a?(::Numeric)\n content << '{'\n values.each { |v|\n content << \"#{get_numeric(v)},\"\n }\n content.chomp!(',')\n content << \"};\\r\\n\"\n else\n content << \"\\r\\n\"\n level.times { content << \"\\t\"}\n content << \"{\\r\\n\"\n values.each { |v|\n (level + 1).times {content << \"\\t\"}\n content << \"\\\"#{v.to_s}\\\",\\r\\n\"\n }\n content.chomp!(\",\\r\\n\")\n content << \"\\r\\n\"\n level.times { content << \"\\t\"}\n content << \"};\\r\\n\"\n end\n content\n end",
"def loners(people)\n lonely_array = []\n for person in people\n if person[:friends] == []\n lonely_array.push(person[:name])\n end\n end\n return lonely_array\nend",
"def name_and_role\n instructors.map do |instructors_hash|\n {instructors_hash[:name] => instructors_hash[:role]}\n end\nend",
"def nickservData(arr)\n return data = {\"rusr\" => arr[0][1..-1].split(\"!\")[0], \"raddress\" => arr[0].split(\"!\")[1], \"to\" => arr[2], \"usr\" => arr[3][1..-1], \"status\" => arr[5]}\n end",
"def getUserGroups(userName)\n\n if(userName == nil)\n return nil\n end\n user = loadUser(userName)\n at = 0\n groupsV = []\n while user[\"group#{at}\"] != nil do\n groupsV <= user[\"group#{at}\"]\n at = at.next\n end\n return groupsV\n\n end",
"def getEmailList\n\t\tdata = index()\n\t\temailList = []\n\t\tdata.each do |person|\n\t\t\temailList.push(\"#{person[\"email_address\"]}\")\n\t\tend\n\t\treturn emailList\n\tend",
"def string_to_nested_array(str)\n arr1 = str.split(',')\n arr2 = []\n for i in 0..arr1.size - 1\n arr2[i] = arr1[i].split(':')\n end\n return arr2\nend"
] |
[
"0.6054917",
"0.57644564",
"0.5720622",
"0.56273395",
"0.55881655",
"0.54471415",
"0.5436326",
"0.5410643",
"0.53270715",
"0.5200718",
"0.5155467",
"0.51475835",
"0.5094791",
"0.50841933",
"0.50824666",
"0.50767744",
"0.5075248",
"0.5067996",
"0.5064469",
"0.5058632",
"0.5058238",
"0.50525415",
"0.50434875",
"0.5020401",
"0.5011211",
"0.49859476",
"0.497908",
"0.49759105",
"0.49471623",
"0.4942349",
"0.4928277",
"0.49262246",
"0.49262246",
"0.49225473",
"0.4909461",
"0.4909369",
"0.4906433",
"0.48985705",
"0.48838004",
"0.48650986",
"0.48645204",
"0.48643428",
"0.4853334",
"0.4846971",
"0.48404303",
"0.4839359",
"0.4832175",
"0.48235965",
"0.4816623",
"0.4812662",
"0.48060596",
"0.48018044",
"0.479328",
"0.47931048",
"0.47860137",
"0.47749084",
"0.47749084",
"0.4772791",
"0.47593346",
"0.47526473",
"0.47518092",
"0.47379518",
"0.4735175",
"0.47318685",
"0.47229314",
"0.47215274",
"0.4719914",
"0.4719914",
"0.47139415",
"0.4712869",
"0.47075337",
"0.47047865",
"0.46992704",
"0.4697896",
"0.4695465",
"0.46919692",
"0.46919045",
"0.46888664",
"0.46870348",
"0.4684291",
"0.46834573",
"0.46795303",
"0.46751302",
"0.46734598",
"0.4667974",
"0.4666432",
"0.46493587",
"0.46478847",
"0.46440375",
"0.464382",
"0.46386153",
"0.46165615",
"0.46164113",
"0.46142712",
"0.46040922",
"0.4598514",
"0.45977688",
"0.45942998",
"0.45898783",
"0.45887467",
"0.45887026"
] |
0.0
|
-1
|
Returns all repos as pythonlike generators
|
def all_repos_as_generator
Enumerator.new do |enum|
each do |repo|
enum.yield repo
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def repos\n pry(Git::Multi.repositories)\nend",
"def all\n return @raw_repos unless @raw_repos.empty?\n return [Template.root.basename.to_s] if Template.project?\n Template.root.join(Meta.new({}).repos_dir).children.map do |path|\n path.basename.to_s\n end\n\n rescue Errno::ENOENT\n then raise(\n Error::RepoNotFound\n )\n end",
"def repos\n @repos ||= OY.repos\n end",
"def all_repos\n\t\tif GitHosting.multi_repos?\n\t\t repositories\n\t\telse\n\t\t [ repository ].compact\n\t\tend\n\t end",
"def list\n @repos\n end",
"def for_each_bitbucket_repo\n @bitbucket_repos.each do |bitbucket_repo_info|\n HybridPlatformsConductor::Bitbucket.with_bitbucket(bitbucket_repo_info[:url], @logger, @logger_stderr) do |bitbucket|\n (bitbucket_repo_info[:repos] == :all ? bitbucket.repos(bitbucket_repo_info[:project])['values'].map { |repo_info| repo_info['slug'] } : bitbucket_repo_info[:repos]).each do |name|\n yield bitbucket, {\n name: name,\n project: bitbucket_repo_info[:project],\n url: \"#{bitbucket_repo_info[:url]}/scm/#{bitbucket_repo_info[:project].downcase}/#{name}.git\",\n jenkins_ci_url: bitbucket_repo_info[:jenkins_ci_url].nil? ? nil : \"#{bitbucket_repo_info[:jenkins_ci_url]}/job/#{name}\",\n checks: bitbucket_repo_info[:checks]\n }\n end\n end\n end\n end",
"def each_repository(&block)\n repositories.values.each(&block)\n end",
"def get_repos\n\t\t@repos = Repo.all\n\tend",
"def get_my_repos\n repos = []\n\n (1..get_total_repo_pages_count.to_i).each do |index|\n get_json( \"#{ GITHUB_USER_REPOS_URL }?per_page=100&page=#{ index }\" ).each do |item|\n repos << item[ 'full_name' ]\n end\n end\n\n return repos\nend",
"def each_module(&block)\n (@modules || {}).each do |type, repos|\n (repos || {}).values.each do |repo|\n yield repo\n end\n end\n end",
"def create_all_repo\n\tLOGGER.info \"Create or checkout all repos\"\n\trepos = Hash.new\n\t$CONFIG[:repos].each do |r|\n\t\tbegin\n\t\t\trepos[ r[:name] ] = CompileRepo.new r\n\t\trescue StandardError => e\n\t\t\terror \"#{r[:name]} #{e} not available, skip\"\n\t\t\tputs e.backtrace\n\t\t\tnext\n\t\tend\n\t\t\n\t\t# Find the result dir\n\t\t`mkdir -p #{CompileRepo.result_abspath}` unless File.directory? CompileRepo.result_abspath\n\t\t`mkdir -p #{repos[ r[:name] ].result_dir}` unless File.directory? repos[ r[:name] ].result_dir\n\tend\n\trepos\nend",
"def acquire_repo_list\n set_auth\n set_github_repo_name\n repo_list = []\n (@github.repos.list org: GITHUB_ORG).each do |l|\n repo_list << l[:name]\n end\n repo_list\nend",
"def get_repos\n # using oauth token to increase limit of request to github api to 5000\n client = Octokit::Client.new :access_token => self.github_token\n (client.repositories self.github_name, {:type => 'all'}).map do |repo|\n repo.full_name\n end\n end",
"def static_list_repositories\n %w[https://github.com/iwc-workflows/sars-cov-2-variation-reporting.git\n https://github.com/iwc-workflows/sars-cov-2-pe-illumina-artic-variant-calling.git\n https://github.com/iwc-workflows/sars-cov-2-ont-artic-variant-calling.git\n https://github.com/iwc-workflows/sars-cov-2-se-illumina-wgs-variant-calling.git\n https://github.com/iwc-workflows/sars-cov-2-pe-illumina-wgs-variant-calling.git\n https://github.com/iwc-workflows/parallel-accession-download.git\n https://github.com/iwc-workflows/sars-cov-2-consensus-from-variation.git\n https://github.com/iwc-workflows/sars-cov-2-pe-illumina-artic-ivar-analysis.git\n https://github.com/iwc-workflows/fragment-based-docking-scoring.git\n https://github.com/iwc-workflows/protein-ligand-complex-parameterization.git\n https://github.com/iwc-workflows/gromacs-mmgbsa.git\n https://github.com/iwc-workflows/gromacs-dctmd.git].map { |r| { 'clone_url' => r }}\n end",
"def repos\n api.repos.map(&:to_hash)\n end",
"def repos\n client.repos({}, query: { sort: \"asc\" })\n end",
"def repos\n @repos ||= (user_repos + org_repos).flatten\n end",
"def all_repos\n if GitHosting.multi_repos?\n repositories\n else\n [ repository ].compact\n end\n end",
"def get_list\n @list_of_repos\n end",
"def repos\n @repos ||= get(\"/repos/show/#{login}\")['repositories'].map { |r| Repo.new(connection, r) }\n end",
"def repositories\n # TODO : merge with current data\n load_repos\n end",
"def list_repos\n repos = []\n end_cursor = nil\n\n data = get_repos(end_cursor)\n repos = repos + data.fetch(\"nodes\")\n next_page = data.dig(\"pageInfo\", \"hasNextPage\")\n end_cursor = data.dig(\"pageInfo\", \"endCursor\")\n\n while next_page do\n data = get_repos(end_cursor)\n repos = repos + data.fetch(\"nodes\")\n next_page = data.dig(\"pageInfo\", \"hasNextPage\")\n end_cursor = data.dig(\"pageInfo\", \"endCursor\")\n end\n\n repos.reject { |r| r.dig(\"isArchived\") || r.dig(\"isDisabled\") }\n end",
"def find_repositories\n @repos = GithubApi.call :repos\n end",
"def repos\n @client.repos.all.collect(&:clone_url)\n end",
"def repos\n ReposAPI.new(self)\n end",
"def gl_repos\n all_repos.select{|x| x.is_a?(Repository::Git)}\n end",
"def repo; end",
"def repo; end",
"def repo; end",
"def repo; end",
"def filterRepositories\n\tEnumerator.new { |repos|\n\t\twhile (gets)\n\t\t\trepo = Repo.new\n\t\t\t$_.sub!(/\\(via.*?\\)/, '') # Remove 'via' annotation in line.\n\t\t\trepo.name, repo.type, repo.url = $_.split(/\\s+/)\n\t\t\t\n\t\t\trepo.score = 0\n\t\t\t\n\t\t\trepos << repo\n\t\tend\n\t}.group_by{|repo| repo.name}.values.each{|repoList|\n\t\tprintBest repoList\n\t}\nend",
"def generators; end",
"def generators; end",
"def find_repos(user)\n user.repos\n end",
"def get_all_user_repos\n user = User.find_by(uuid: params[:uuid])\n\n client = Octokit::Client.new(:access_token => user.password)\n repo_list = []\n client.repositories(:user => user.gh_username).each { |repo|\n repo_list.push(repo.name)\n }\n render :json => {:repos => repo_list}\n end",
"def get_repos\n @api.list_repositories\n end",
"def repos(opts={ push: false, details: false, orgs: true })\n repos = @client.repositories.map {|repo| parse_repo repo}\n @client.organizations.each do |org|\n repos += @client.organization_repositories(org.login).map {|repo| parse_repo repo}\n end\n repos.reject! {|repo| !repo[:push]} if opts[:push]\n repos.map { |repo| repo[:full_name] } unless opts[:details]\n end",
"def get_repo_content(type, username, repo_name) # :yields: String\n case type\n\n when Api_options::REPO::LANGUAGES\n \"#{BASE_URL}\" + \"#{REPOS}\" + \"#{username}/\" + \"#{repo_name}/languages\"\n when Api_options::REPO::CONTRIBUTORS\n BASE_URL + REPOS + \"#{username}\" + \"/\" + \"#{repo_name}\" + \"/\" + \"contributors\"\n when Api_options::REPO::README\n BASE_URL + REPOS + \"#{username}\" + \"/\" + \"#{repo_name}\" + \"/\" + \"readme\"\n end\n end",
"def get_github_repos_already_cloned\n repos = Array.new\n\n configatron.dir.children.each do |repo_name|\n if repo_name.directory?\n begin\n repo = Github.repos.get(\n user: ENV['GITHUB_ACCOUNT'],\n oauth_token: ENV['GITHUB_API_TOKEN'],\n repo: repo_name.basename.to_s\n )\n rescue Exception => e\n puts \"\\n#{e}\"\n next\n end\n repos << repo if repo.fork\n end\n end # configatron.dir.children.each do |repo_name|\n\n return repos\nend",
"def repos\n super.sort\n end",
"def repositories\n response = self.class.get('/repositories').body\n JSON.parse(response)\n end",
"def list\n @connection.get('/user/repos').map do |repo_data|\n Rails.logger.info \"listing repos\"\n GitHubApi::Repo.new(self, repo_data)\n end\n end",
"def get_repos\n begin\n @repos ||= github_api_setup.repos.list\n rescue Exception => e\n logger.error \"Github #get_repos error #{e}\"\n end\n end",
"def get_repo_list(token, user)\n query = %{\n query ($user: String!, $cursor: String) {\n user(login: $user) {\n repositories(first: 100, after: $cursor) {\n edges {\n node {\n name\n owner {\n login\n }\n }\n }\n pageInfo {\n hasNextPage\n endCursor\n }\n }\n }\n }\n }\n\n vars = { user: user, cursor: nil }\n\n repos = []\n\n loop do\n result = Github.query(token, query, vars)\n repos += result.dig(\"data\", \"user\", \"repositories\", \"edges\") || []\n break unless result.dig(\"data\", \"user\", \"repositories\", \"pageInfo\", \"hasNextPage\")\n vars[:cursor] = result.dig(\"data\", \"user\", \"repositories\", \"pageInfo\", \"endCursor\")\n end\n\n repos.map { |e| { owner: e.dig(\"node\", \"owner\", \"login\"), name: e.dig(\"node\", \"name\") } }\nend",
"def find_all(repo, options = {})\n refs = []\n already = {}\n Dir.chdir(repo.path) do\n files = Dir.glob(prefix + '/**/*')\n files.each do |ref|\n next if !File.file?(ref)\n id = File.read(ref).chomp\n name = ref.sub(\"#{prefix}/\", '')\n commit = Commit.create(repo, :id => id)\n if !already[name]\n refs << self.new(name, commit)\n already[name] = true\n end\n end\n\n if File.file?('packed-refs')\n File.readlines('packed-refs').each do |line|\n if m = /^(\\w{40}) (.*?)$/.match(line)\n next if !Regexp.new('^' + prefix).match(m[2])\n name = m[2].sub(\"#{prefix}/\", '')\n commit = Commit.create(repo, :id => m[1])\n if !already[name]\n refs << self.new(name, commit)\n already[name] = true\n end\n end\n end\n end\n end\n\n refs\n end",
"def chunked_repo_sets \n all_repositories = Dir.entries(OBSERVATIONS_DIR).select{|x| x != '.' && x != '..' && x != '.DS_Store'}.map{|x| \"#{OBSERVATIONS_DIR}/\" + x}\n stride = 500\n start_i = 0\n end_i = stride - 1\n repo_count = all_repositories.size\n repo_sets = Array.new\n while start_i < repo_count do\n end_i = repo_count - 1 if end_i >= repo_count\n next_set = all_repositories[start_i..end_i]\n repo_sets << next_set\n start_i = end_i + 1\n end_i += stride\n end\n repo_sets\nend",
"def process_repos\n url_template = if @options.preview\n 'https://api.github.com/search/issues?q=is:pr+repo:cockpit-project/REPO+label:release-note'\n else\n 'https://api.github.com/search/issues?q=is:pr+repo:cockpit-project/REPO+label:release-note+is%3Aclosed'\n end\n tags_template = 'https://api.github.com/repos/cockpit-project/REPO/tags'\n\n @repos.map do |repo|\n # Grab relevant issues for the repo\n url = url_template.sub('REPO', repo)\n\n # Process versions\n url_tags = tags_template.sub('REPO', repo)\n versions = get_json(url_tags).map { |tag| tag['name'].to_i }.sort\n # Set the Cockpit version from the first repo (which is always Cockpit)\n @cockpit_version ||= versions.last + @increment\n\n notes = get_json(url)['items']\n .map { |issue| format_issue(issue, repo) }\n\n process_meta(repo, versions) unless notes.empty?\n\n notes\n end\nend",
"def sources\n @sources ||= ApiFactory.new 'Repos::Sources'\n end",
"def generators\n @generators ||= []\n end",
"def generators\n @generators ||= []\n end",
"def repositories\n octokit.repositories('zold-io').map { |json| json['full_name'] }\n end",
"def each_module_of_type(type, &block)\n abort(\"undefined type #{type}\") unless [:git, :tarball].include?(type)\n ((@modules || {})[type] || {}).values.each do |repo|\n yield repo\n end\n end",
"def packages\n packages = []\n @repositories.each do |repo|\n repo_packages = repo.packages\n repo_packages.map { |p| packages.push(p) } unless repo_packages.empty?\n end\n packages\n end",
"def repositories\n\t\t\telems = []\n\t\t\tget_resource_link(:datacenterrepositories, \"datacenterRepositories\", \"datacenterRepository\").each do |data|\n\t\t\t\telems << Repository.new(data)\n\t\t\tend\n\t\t\telems\n\t\tend",
"def find_all\n Regulate::Git::Interface.find_all.collect do |resource_data|\n self.new_from_git( resource_data )\n end\n end",
"def get_repo_list\n Chef::Log.debug(\n \"Fetching all versions of #{new_resource.module_name} \" +\n \"from #{new_resource.repository}.\",\n )\n latest = powershell_out!(\n <<-EOH,\n $splat = @{\n Name = \"#{new_resource.module_name}\"\n Repository = \"#{new_resource.repository}\"\n AllVersions = $True\n }\n (Find-Module @splat).Version.ForEach({$_.ToString()})\n EOH\n ).stdout.to_s.chomp.split(\"\\r\\n\")\n Chef::Log.debug(\"Available versions: #{latest.join(', ')}\")\n\n return latest.map { |v| Gem::Version.new(v) }\n end",
"def org_repos\n @org_repos ||= (\n talk 'org repos'\n logins = orgs.map { |org| org[:login] }\n\n logins.map do |login|\n talk \"repos for #{login}\"\n client.organization_repositories login.to_s\n end.flatten\n )\n end",
"def repositories\n Repositories.instance\n end",
"def index\n @repos = Repo.all\n end",
"def repositories_with_pull_requests(reponames = [])\n repositories = []\n page = 1\n loop do\n repositories_in_page = load_repos_in_page(page)\n break if repositories_in_page.empty?\n repositories.concat(repositories_in_page)\n page += 1\n end\n repositories.select! { |repo| reponames.include?(repo.name) } unless reponames.empty?\n repositories.select!(&:any_pull_requests?)\n repositories\n end",
"def list_repositories\n return static_list_repositories if false\n super.select do |repo|\n sleep 1\n begin\n github[\"repos/#{repo['full_name']}/contents/.dockstore.yml\"].head\n sleep 1\n rescue RestClient::NotFound\n output.puts \"No .dockstore.yml found in #{repo['full_name']}, skipping\"\n end\n end\n end",
"def get_repos\n\t\trepo_list = []\n\t\tparsed_config = begin\n\t\t\tYAML.load(File.open(@path_to_config_yml))\n\t\trescue ArgumentError => e\n \t\t\tputs \"Could not parse YAML: #{e.message}\"\n\t\tend\n\t\tparsed_config['sections'].each do |section|\n\t\t\trepo_list.push(section['repository']['name'].gsub(/\\w*-?\\w*\\//,''))\n\t\tend\n\t\trepo_list.sort\n\tend",
"def all\n repos = self.class.load_json(repos_url)\n repos.map! { |repo| self.class.filter_repo_info(repo) }\n self.class.slice_in(repos, 3)\n end",
"def get_repositories\n get(\"#{url_base}/repositories?#{dc}\")[\"data\"]\n end",
"def each_group_repo\n failed_groupings = []\n self.groupings.each do |grouping|\n begin\n grouping.access_repo do |repo|\n yield(repo)\n end\n rescue StandardError\n # in the event of a concurrent repo modification, retry later\n failed_groupings << grouping\n end\n end\n failed_groupings.each do |grouping|\n begin\n grouping.access_repo do |repo|\n yield(repo)\n end\n rescue StandardError\n # give up\n end\n end\n end",
"def for_each_submodule &block\n status = %x{git submodule status}\n # status.each {|line| puts line unless line =~ /^ /} # print if any are out of sync with origin. [i find i ignore this. YMMV. -mike]\n status.each {|line| yield line.split()[1] }\nend",
"def initialize_grit_repos (git_repos)\n\tgit_repos['rugged'] = []\n\tgit_repos['includes'].each do | path |\n\t\tgit_repos['rugged'].push(Rugged::Repository.new(path))\n\tend\nend",
"def getprojects()\n printRepoHeader\n \n loop do\n # Print each of the new returned repositories\n begin\n get.each do |repo|\n printRepo(repo) if (@slugs.add?(repo['slug']))\n\n # Flush to prevent data loss if we crash\n STDOUT.flush\n end\n rescue Exception => msg\n STDERR.puts \"WARNING: Poll failed at #{Time.now}\"\n STDERR.puts msg\n end\n\n # Poll every 5 minutes\n sleep 300\n end\n end",
"def repositories\n client.repositories(user_repo, @options)\n end",
"def each\n @sources.each { |directory, path| yield directory, path }\n end",
"def repo\n @repo\n end",
"def all\n storage.map(&:repository)\n end",
"def repos(show_commits = false)\n response = @github.repos.list(user: 'siakaramalegos', sort: 'updated', direction: 'desc', page: 1, per_page: 10)\n repos = response.body\n\n repos.each_with_index do |repo, index|\n puts '-' * 80\n date_string = repo.updated_at\n date = DateTime.parse(date_string).to_date\n puts \"(#{index + 1}) #{repo.name}: #{repo.description} (updated: #{date.stamp('12/30/99')})\"\n\n if show_commits\n repo_commits = @github.repos.commits.list('siakaramalegos', repo.name, page: 1, per_page: 10).body\n\n repo_commits.each do |c|\n date_string = c.commit.author.date\n date = DateTime.parse(date_string).to_date\n puts \" #{c.commit.message} (#{date.stamp('12/30/99')})\"\n end\n end\n end\n puts '-' * 80\n repos\n end",
"def list_all_registered_repos\n data, code = get_json(@all_repos_path)\n return data,code\n end",
"def team_repositories\n team_profiles.map(&:repositories).flatten\n end",
"def repo_commands( &block )\n\t\traise LocalJumpError, \"no block given\" unless block\n\n\t\tmod = Module.new\n\t\tmod.class_eval( &block )\n\n\t\tHglib::Repo.include( mod )\n\tend",
"def gather_repos(books)\n\tbooks.each do |book|\n\t\tYAML.load(File.open(Dir.home + '/workspace/' + book + '/config.yml'))['sections'].each do |section| \n\t\t\t@repo_list.push(section['repository']['name'])\n\t\tend\n\tend\n\t@repo_list.delete('cloudfoundry/uaa')\n\treview_check @repo_list.uniq\nend",
"def list_repositories\n JSON.parse(request(:get, ''))\n end",
"def get_cookbooks\n cookbooks = []\n Dir.foreach($opts[:repo]) do |cookbook_dir|\n if File.directory?(File.join($opts[:repo], cookbook_dir)) && !cookbook_dir.start_with?('.')\n cookbooks << cookbook_dir\n end\n end\n cookbooks\nend",
"def repos(login, name = nil)\n repo = name.nil? ? login : \"#{login}/#{name}\"\n path_prefix = \"./repos/#{repo}\"\n proxy = Proxy.new(connection, path_prefix)\n proxy.repo_name = repo\n proxy\n end",
"def user_repos\n @user_repos ||= (\n talk 'user repos'\n client.repos\n )\n end",
"def repo\n @repo ||= Rugged::Repository.discover('.')\n end",
"def refresh\n list.clear\n\n Ginatra.load_config[\"git_dirs\"].map do |git_dir|\n if Dir.exist?(git_dir.chop)\n dirs = Dir.glob(git_dir).sort\n else\n dir = File.expand_path(\"../../../#{git_dir}\", __FILE__)\n dirs = Dir.glob(dir).sort\n end\n\n dirs = dirs.select {|f| File.directory? f }\n dirs.each {|d| add(d) }\n end\n\n list\n end",
"def get_public_repos(user_name)\n get(\"/users/#{user_name}/repos\")\n end",
"def generators\n generators = []\n section_found = false\n `cmake --help`.each_line do |line|\n section_found = true if line =~ /^Generators/\n next unless section_found\n generators << $1 if line =~ /^ (\\S.*?)(?: \\[arch\\])?\\s*(=|$)/\n end\n return generators\nend",
"def get_repo_names github_username , git_token\n\n Rails.cache.fetch(\"#{self.id}/repo_names\", expires_in: 6.hours) do\n repo_names = Array.new\n github = Github.new :oauth_token => git_token\n\n github.repos.list.body.each do |repo|\n if github_username == repo[\"owner\"][\"login\"]\n repo_names << { :user=>github_username ,:repo=>repo[\"name\"]}\n end\n end\n\n orgs_names = Array.new\n github.orgs.list.each do |org|\n orgs_names << org[\"login\"]\n end\n\n orgs_names.each do |oname|\n url = \"orgs/\"+oname+\"/repos\"\n \n github.get_request(url,Github::ParamsHash.new({})).each do |orepo|\n if oname == orepo[\"owner\"][\"login\"]\n repo_names << { :user=>oname ,:repo=>orepo[\"name\"]}\n end\n end\n end\n repo_names\n end\n end",
"def get_remotes()\n to_return = {}\n count = 1\n num_dirs = Dir.glob('./*/').size() -2 # exclude . and ..\n Dir.glob('./*/').each() do |dir|\n next if dir == '.' or dir == '..'\n\n print \"Processing directories...#{count}/#{num_dirs}\\r\" if !$verbose\n count += 1\n\n if(File.directory?(dir) and File.exists?(dir + '/.git'))\n Dir.chdir dir\n remotes = `git remote -v`.split(\"\\n\")\n\n vprint(dir.ljust(25))\n remotes.each() do |remote|\n if(remote.index('(fetch)'))\n parts = remote.split(\"\\t\")\n\n remote_name = get_remote_name(parts[1])\n vprint(\"[#{parts[0]} #{remote_name}]\".ljust(20))\n if(remote_name != nil)\n index = parts[0] + ' - ' + remote_name\n if(to_return[index] == nil)\n to_return[index] = Array.new()\n end\n to_return[index].push(dir)\n else\n puts \"\\nDon't know what to do with #{remote} in dir #{dir}\"\n end\n end\n end # end remotes loop\n\n vprint \"\\n\"\n Dir.chdir '..'\n end # end if file.directory\n end\n\n print \"\\n\"\n return to_return\nend",
"def repo *extras, &block\n old_repo = @repo if defined? @repo\n @repo = repo = Gem::Repo.new(Dir.mktmpdir, *extras)\n\n begin\n yield repo\n ensure\n @repo = old_repo\n FileUtils.rm_rf repo.home\n end\n\n repo\n end",
"def fetch_repositories(repos = nil)\n # Init git settings\n Git.configure do |config|\n config.binary_path = \"#{@config['git']['path']}\"\n end\n @return_repos = []\n # Loop through repos and fetch it\n repos_to_fetch = repos.nil? ? self.repositories_to_fetch : repos\n repos_to_fetch.each do |repo|\n if File.directory?(repo)\n # Get branches\n g = Git.bare(\"#{repo}\", :log => @log)\n g.remotes.each do |remote|\n # Determine which \"remote\" to fetch e.g. \"git fetch github\"\n if @config['provider'].include?(\"#{remote}\")\n @log.info(\"Fetching remote #{remote} in #{repo}\")\n g.remote(remote).fetch\n @return_repos << repo\n end\n end\n end\n end\n @return_repos\n end",
"def get_repo_list(ssh: false)\n CSV.generate do |csv|\n self.groupings.includes(:group).each do |grouping|\n group = grouping.group\n data = [group.group_name, group.repository_external_access_url]\n data << group.repository_ssh_access_url if ssh\n csv << data\n end\n end\n end",
"def get_repo_users\n repo_users = Array.new\n github = Github.new :oauth_token => github_token\n\n github.repos.list.body.each do |repo|\n repo_users << repo[\"owner\"][\"login\"]\n end\n\n repo_users\n end",
"def get_repos\n\t\tif current_user.nil?\n\t\t\t@repos = Repo.where(:user_id => nil)\n\t\telse\n\t\t\t@repos = current_user.repos\n\t\tend\n\tend",
"def generators(&blk); end",
"def generators(&blk); end",
"def get_user_repos(username) # :yields: JSON\n uri=URI.parse(@@uri_builder.user_repos_url(username,@@app_token))\n http=HttpHandler.initiate_http(uri)\n begin\n response=HttpHandler.get_response(http,uri)\n rescue ArgumentError\n puts \"Request failed with code: #{response.code}\"\n else\n @@responseStatus=true\n return response\n end\n end",
"def each_autobuild_package\n return enum_for(__method__) unless block_given?\n\n each_package_definition { |pkg| yield(pkg.autobuild) }\n end",
"def get_repos_by_orga(orga) \n\t\treturn self.fetch(\"repos?owner_name=#{orga}\")\n\tend",
"def get_contributors_of_a_repository(username,repo_name) # :yields: JSON\n uri=URI.parse(@@uri_builder.get_repo_content(Api_options::REPO::CONTRIBUTORS,username,repo_name))\n http= HttpHandler.initiate_http(uri)\n begin\n response=HttpHandler.get_response(http,uri)\n rescue ArgumentError\n puts \"Request failed with code: #{response.code}\"\n else\n @@responseStatus=true\n return response\n end\n end",
"def generate!\n generator.invoke_all\n end"
] |
[
"0.6886352",
"0.6706091",
"0.6547711",
"0.6488232",
"0.64740634",
"0.64513975",
"0.6448159",
"0.64425504",
"0.6407408",
"0.6400587",
"0.6387641",
"0.6384363",
"0.63795084",
"0.63451135",
"0.63272053",
"0.63034374",
"0.6265424",
"0.6264255",
"0.62005675",
"0.61952955",
"0.6194929",
"0.6184454",
"0.6155351",
"0.61514896",
"0.61079156",
"0.6086183",
"0.6071127",
"0.6071127",
"0.6071127",
"0.6071127",
"0.604253",
"0.6022505",
"0.6022505",
"0.6017793",
"0.60031027",
"0.59731",
"0.5972987",
"0.5953804",
"0.59418285",
"0.59293854",
"0.5917075",
"0.5913058",
"0.59121513",
"0.5910302",
"0.5904039",
"0.5875201",
"0.5870094",
"0.58410287",
"0.583507",
"0.583507",
"0.5832559",
"0.58212316",
"0.58103544",
"0.5807386",
"0.57809156",
"0.57590413",
"0.5734138",
"0.5700857",
"0.5696854",
"0.56925315",
"0.56885946",
"0.56872994",
"0.5668482",
"0.5661227",
"0.5656708",
"0.56459224",
"0.56417304",
"0.56377065",
"0.562813",
"0.5624804",
"0.5624775",
"0.56192636",
"0.5618886",
"0.5618205",
"0.5568042",
"0.5562574",
"0.5560204",
"0.5560005",
"0.55488795",
"0.55300796",
"0.5523899",
"0.55199987",
"0.5513947",
"0.55069286",
"0.55046403",
"0.5499658",
"0.549821",
"0.54948163",
"0.54797226",
"0.5465093",
"0.54531944",
"0.54521024",
"0.54507405",
"0.54507405",
"0.54481745",
"0.5443732",
"0.5442573",
"0.5431094",
"0.5425605"
] |
0.81309724
|
1
|
GET /feed_entries/1 GET /feed_entries/1.json
|
def show
@feed_entry = FeedEntry.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.json { render json: @feed_entry }
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def show\n @feed = Feed.find(params[:id])\n @entries = EntryFeed.where(:feed_id => @feed.id)\n\n if @entries.blank?\n EntryFeed.create_from_feed(@feed)\n @entries = EntryFeed.where(:feed_id => @feed.id)\n end\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @feed }\n end\n end",
"def show\n @feed = Feed.find(params[:id])\n @related_feeds = @feed.list_related_feeds(current_user)\n @feed_entries = Entry.where(feed_id: @feed.id).order(\"updated_at DESC\").page(params[:page]).per(10)\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @feed }\n end\n end",
"def new\n @feed = Feed.find(params[:feed_id])\n @entry = @feed.entries.new\n respond_to do |format|\n format.html { render :layout => 'feed'}\n format.json { render json: @entry }\n end\n end",
"def show\n @feed = Feed.find(params[:feed_id])\n @entry = Entry.find(params[:id])\n respond_to do |format|\n format.html { render :layout => 'feed'}\n format.json { render json: @entry }\n end\n end",
"def index\n #body, ok = SuperfeedrEngine::Engine.retrieve(Feed.first) \n @entries = Entry.all\n end",
"def show\n @feedentry = Feedentry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @feedentry }\n end\n end",
"def index\n @feed_entries = FeedEntry.all\n end",
"def entries\n Entry.where(:feed_id => pk)\n end",
"def feed\n @feed_items = @repository.recent_feed_items\n respond_to do |format|\n format.html # feed.html.erb\n format.json { render json: @feed_items }\n end\n end",
"def index\n @feeds = Feed.all\n\n # fetching a single feed\n #@feed = Feedzirra::Feed.fetch_and_parse(\"http://feeds.feedburner.com/PaulDixExplainsNothing\")\n\n # @entries = @feed.entries\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @feeds }\n end\n end",
"def show\n render json: NewsEntry.find(params[:id]).to_json(include: [:feed])\n end",
"def show\n @feed = FlexibleFeeds::Feed.find(params[:id])\n\n render json: @feed\n end",
"def show\n @category = Category.find(params[:id])\n @feeds = @category.feeds\n @entries = @category.entries.includes([:feed, :clip]).page params[:page]\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => {\n :category => @category,\n :feeds => @feeds,\n :entries => @entries # TODO entryごとのclipがjsonに含まれてない\n }}\n end\n end",
"def index\n @entries = Entry.desc(:created_at).page(params[:page] || 1).per(10)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @entries }\n end\n end",
"def show\n @entry = Entry.find(params[:id])\n\n render json: @entry\n end",
"def rss_entries(url)\n\t\tresponse = fetch(url)\n\t\tresponse[\"feed\"][\"entry\"]\n\tend",
"def index\n @entries = Entry\n .paginate(:page => params[:page], :per_page => 10)\n .find_all_by_entry_type(params[:entry_type].presence || 'post', :include => :user)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @entries }\n end\n end",
"def show\n @blog = EntryFeed.where(:id => params[:id]).first\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @blog }\n end\n end",
"def new\n @feed_entry = FeedEntry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed_entry }\n end\n end",
"def show\n @entry = Entry.find(params[:id])\n respond_to do |format|\n format.html {}\n format.json { render json: @entry }\n end\n end",
"def show\n @feed = Feed.find(params[:id])\n @posts = @feed.posts.order(\"published desc\").paginate(:page => params[:page], :per_page => 20)\n \n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @feed }\n end\n end",
"def new\n @feedentry = Feedentry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feedentry }\n end\n end",
"def index\n @feed_items = @user.feed_items\n render json: @feed_items\n end",
"def show\n render :json => Feed.find(params[:id]) \n end",
"def show\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def show\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def show\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def show\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def show\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def show\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def show\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def show\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def show\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def show\n @feed_item = Item.find(params[:id])\n\n render json: @feed_item\n end",
"def show\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @entry }\n end\n end",
"def feed\n @posts = Post.feed_of(params[:id])\n end",
"def fetch!\n parsed_feed = FeedNormalizer::FeedNormalizer.parse open(self.feed_url)\n \n self.update_attributes( :title => parsed_feed.title,\n :url => parsed_feed.url\n #:etag => parsed_feed.etag\n #:last_modified => parsed_feed.last_modified\n )\n \n parsed_feed.entries.each do |entry|\n self.entries.create(:url => entry.url,\n :title => entry.title,\n :author => entry.author,\n #:summary => entry.summary,\n :content => entry.content\n #:published => entry.published\n #:categories => entry.categories\n ) if !Entry.find_by_url(entry.url)\n end\n end",
"def show\n @entry = @time_sheet.entries.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def index\n @feed = Feed.new\n @feeds = Feed.all :order => :title\n \n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @feeds }\n end\n end",
"def index\n @feed_entries = FeedEntry.all\n @title = \"Feeds List\"\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @feed_entries }\n end\n end",
"def show\n @series = Series.find(params[:id])\n @feeds = Feed.where(series_id: params[:id])\n @feeds.each do |feed|\n @entries = Entry.where(feed_id: feed.id).order(:created_at).page params[:page]\n end\n \n end",
"def show\n @mypost = Mypost.find(params[:id])\n\t@myposts = Mypost.all\n @feed_me_items = []\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @mypost }\n end\n\t\n end",
"def index\n @user = User.find(params[:user_id])\n @entries = @user.entries.paginate(:page => params[:page], :per_page => 10).order('created_at DESC')\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @entries }\n end\n end",
"def show\n @feed_entry = FeedEntry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.xml { render :xml => @feed_entry }\n end\n end",
"def create\n @feed = Feed.find(params[:feed_id])\n @entry = @feed.entries.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n @entry.author.save\n format.html { redirect_to feed_entry_path(@feed,@entry), notice: 'Entry was successfully created.' }\n format.json { render json: feed_entry_path(@feed, @entry), status: :created, location: feed_entry_path(@feed, @entry) }\n else\n format.html { render action: \"new\" }\n format.json { render json: feed_entry_path(@feed,@entry).errors, status: :unprocessable_entity }\n end\n end\n end",
"def demo1\n @feed_entries = []\n \n (4..7).each do |channelnum|\n json_str = Net::HTTP.get(URI.parse(\"http://\" + THINGSPEAK_SERVER + \"/channels/#{channelnum}/feed.json?results=5\"))\n parsed_hash = ActiveSupport::JSON.decode(json_str)\n parsed_hash[\"feeds\"].each do |e|\n entry = {}\n t = Time.strptime(e[\"created_at\"], \"%FT%T%z\")\n entry[\"time\"] = t\n entry[\"created_at\"] = t.strftime(\"%H:%M\")\n entry[\"field1\"] = e[\"field1\"].to_i\n entry[\"field2\"] = e[\"field2\"]\n @feed_entries.push(entry)\n end\n end\n @feed_entries.sort! { |a,b| b[\"time\"] <=> a[\"time\"] }\n end",
"def retrieve_feed\n uri = URI.parse(@feed_url)\n Net::HTTP.get_response(uri).body\n end",
"def feed\n get '/users/self/feed', auth_params\n end",
"def index\n @entries = list_entries\n respond_with @entries\n end",
"def index\n @entries = @time_sheet.entries\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @entries }\n end\n end",
"def show\n @entry_view = EntryView.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry_view }\n end\n end",
"def index\n @entries = Entry.all\n end",
"def index\n @entries = Entry.all\n end",
"def index\n @entries = Entry.all\n end",
"def index\n @entries = Entry.all\n end",
"def index\n @entries = Entry.all\n end",
"def index\n @entries = Entry.all\n end",
"def show\n @feed = current_user.feeds.find_by_slug(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @feed }\n end\n end",
"def index\n @entries = Entry.order('created_at DESC')\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @entries }\n end\n end",
"def get_all_entries\n @feed_entries = FeedEntry.find(:all, :conditions => { :person_id => self.id}, :order => 'published_at DESC')\n end",
"def index\n @posts = Post.limit 50\n @title = \"Weblog - last posts\"\n @updated = @posts.first.created_at unless @posts.empty?\n respond_to do |format|\n format.rss do\n redirect_to feeds_path(format: :atom),\n status: :moved_permanently\n end\n format.atom\n end\n end",
"def show\n @feed = Feed.find(params[:id])\n end",
"def show\n @feed = Feed.find(params[:id])\n end",
"def show\n @feed = Feed.find(params[:feed_id])\n @article = Article.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @article }\n end\n end",
"def show\n @entry = Entry.where(:numid => params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @entry }\n end\n end",
"def fetch_urls_from_feedly\n yaml = YAML.load_file('env.yaml')\n client = Feedlr::Client.new(oauth_access_token: yaml['account']['feedly']['access_token'])\n client.user_subscriptions.map{|m|\n # puts m.id\n hotentries = client.stream_entries_contents(m.id, :count => 5 ).items\n return hotentries\n };\nend",
"def index\n @places = @places.page params[:page]\n\n @feed_link = places_url(:format => :atom)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @places }\n format.atom { render :layout => false }\n end\n end",
"def show\n @rss_feed = RssFeed.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @rss_feed }\n end\n end",
"def feed_entries(feed, include_read: false, page: nil)\n EntriesPagination.feed_entries feed, self, include_read: include_read, page: page\n end",
"def show\n @feed = Feed.find(params[:id])\n #@feeds = Feed.from_users_followed_by(current_user)\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @feed }\n end\n end",
"def index\n @entries = Entry.all.first(100)\n end",
"def index\n @entries = Entry.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @entries }\n end\n end",
"def index\n @entries = Entry.all;\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @entries }\n end\n end",
"def index\n @entries = Entry.find_all_by_time(params[:date], :order => :created_at)\n @entry ||= Entry.new\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @entries }\n end\n end",
"def index_rest\n @entry_items = EntryItem.find(:all)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @entry_items }\n end\n end",
"def get_atom_entry(url)\n res = get(url, \"Accept\" => \"application/atom+xml\")\n\n # XXX handle other HTTP codes\n if res.code != \"200\"\n raise Atom::HTTPException, \"failed to fetch entry: expected 200 OK, got #{res.code}\"\n end\n\n # be picky for atom:entrys\n res.validate_content_type( [ \"application/atom+xml\" ] )\n\n Atom::Entry.parse(res.body, url)\n end",
"def new\n @feed = Feed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed }\n end\n end",
"def new\n @feed = Feed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed }\n end\n end",
"def new\n @feed = Feed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed }\n end\n end",
"def new\n @feed = Feed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed }\n end\n end",
"def index\n @title = \"医药招商\"\n @entries = Entry.recent.includes(:user).page(params[:page] || 1).per(30)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @entries }\n end\n end",
"def new\n @feed = Feed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @feed }\n end\n end",
"def show\n @entry = Entry.where(id: params[:id]).first\n @entry.increment!(:view_count)\n render json: @entry.to_json\n end",
"def index\n @posts = Post.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @posts }\n format.atom\n end\n end",
"def entries\n uri = URI(BASE_URL + ENTRIES_ENDPOINT + days_query)\n\n make_request(uri)\n end",
"def feed\n @articles = Article.feed_list(current_user, params[:page])\n end",
"def friend_feed(options={})\n get('/feed', options)\n end",
"def feed\r\n @posts = Post.all(:order => \"created_at DESC\")\r\n respond_to do |format|\r\n format.rss\r\n end\r\n end",
"def show\n\n update_feed(@feed)\n\n @items = @feed.items.order('pub_date DESC').page params[:page]\n\n end",
"def getFeed\n\t\t\tresponse = HTTP.get(\"https://graph.facebook.com/v2.12/#{self.page_resource}/feed?access_token=#{ENV['FB_ACCESS_TOKEN']}\")\n\t\t\tfeedHash = JSON.parse(response.body)\n\t\t\tposts = feedHash[\"data\"].collect do |feed|\n\t\t\t\t\tfb_created = Date.parse(feed[\"created_time\"])\n\t\t\t\t\tcontent = feed[\"message\"]\n\t\t\t\t\tstory = feed[\"story\"]\n\t\t\t\t\tfb_id = feed[\"id\"]\n\t\t\t\t\toldPost = self.posts.where(fb_id: fb_id)\n\t\t\t\t\t\n\t\t\t\t\tif oldPost.empty? && !content.nil?\n\t\t\t\t\t\tself.posts.create(fb_id: fb_id, content: content, fb_created: fb_created.strftime('%m/%d/%Y'), story: story)\n\t\t\t\t\tend\n\t\t\tend \t\n\tend",
"def show\n @feed_element = FeedElement.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @feed_element }\n end\n end",
"def show\n @moment_entry = MomentEntry.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render json: @moment_entry }\n end\n end",
"def index\n @feeds = Feed.all\n end",
"def index\n @feeds = Feed.all\n end",
"def index\n @feeds = Feed.all\n end",
"def index\n @feeds = Feed.all\n end",
"def index\n @feeds = Feed.all\n end",
"def feed\n offset, limit = pagination_values\n id = params.require(:id)\n feed_users_ids = UserFollowing.where(user_id: id).pluck(:following_id) << id\n feed_posts = Post.select(:id, :description, :author_id, :created_at, :updated_at).where(author: feed_users_ids).order(created_at: :desc).offset(offset).limit(limit)\n if stale? feed_posts\n render json: PostSerializer.array_to_json(feed_posts, {success: true, offset: offset, limit: limit}) , status: :ok\n end\n end",
"def show\n @feed_category = FeedCategory.find(params[:id])\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @feed_category }\n end\n end",
"def index\n @feed_items = FeedItem.all\n end"
] |
[
"0.77304965",
"0.7627515",
"0.73237264",
"0.73084277",
"0.7175086",
"0.7175017",
"0.71232295",
"0.7010187",
"0.7007073",
"0.69571435",
"0.69366586",
"0.6868748",
"0.6859293",
"0.6788085",
"0.6766332",
"0.66928005",
"0.6673857",
"0.6669177",
"0.6668894",
"0.6667361",
"0.66570485",
"0.66099054",
"0.6586551",
"0.6497792",
"0.64943963",
"0.64943963",
"0.64943963",
"0.64943963",
"0.64943963",
"0.64943963",
"0.64943963",
"0.64943963",
"0.64943963",
"0.64598596",
"0.644168",
"0.6418439",
"0.64080405",
"0.64010537",
"0.6383381",
"0.6377995",
"0.63322717",
"0.6329624",
"0.6319704",
"0.6316787",
"0.6301921",
"0.628243",
"0.6279678",
"0.6278074",
"0.62615126",
"0.62471914",
"0.62385476",
"0.62354463",
"0.62354463",
"0.62354463",
"0.62354463",
"0.62354463",
"0.62354463",
"0.6231875",
"0.6226719",
"0.62022567",
"0.6195797",
"0.6190608",
"0.6190608",
"0.6184199",
"0.6176834",
"0.6169781",
"0.6169704",
"0.6164146",
"0.616153",
"0.6161358",
"0.61500543",
"0.6141433",
"0.61406064",
"0.6121211",
"0.61161524",
"0.61110014",
"0.61022466",
"0.61022466",
"0.61022466",
"0.61022466",
"0.6100012",
"0.6071208",
"0.6065485",
"0.60587406",
"0.60514235",
"0.60405594",
"0.6030444",
"0.60281867",
"0.60146385",
"0.60093474",
"0.60015434",
"0.59997123",
"0.59977776",
"0.59977776",
"0.59977776",
"0.59977776",
"0.59977776",
"0.5991678",
"0.5980762",
"0.5963474"
] |
0.72590834
|
4
|
GET /feed_entries/new GET /feed_entries/new.json
|
def new
@feed_entry = FeedEntry.new
respond_to do |format|
format.html # new.html.erb
format.json { render json: @feed_entry }
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def new\n @feed = Feed.find(params[:feed_id])\n @entry = @feed.entries.new\n respond_to do |format|\n format.html { render :layout => 'feed'}\n format.json { render json: @entry }\n end\n end",
"def new\n @feedentry = Feedentry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feedentry }\n end\n end",
"def new\n @feed = Feed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed }\n end\n end",
"def new\n @feed = Feed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed }\n end\n end",
"def new\n @feed = Feed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed }\n end\n end",
"def new\n @feed = Feed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed }\n end\n end",
"def new\n @entry = Entry.new\n\n render json: @entry\n end",
"def new\n @feed = Feed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @feed }\n end\n end",
"def new\n @entry = Entry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def new\n @entry = Entry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def new\n @entry = Entry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def new\n @entry = Entry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def new\n @entry = Entry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def new\n @entry = Entry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def new\n @entry = Entry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def new\n @entry = Entry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def new\n @entry = Entry.new(:entry_type => params[:entry_type].presence || 'post', :comment_status => 'open', :user_id => current_user.id)\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def new\n @feed_item = FeedItem.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed_item }\n end\n end",
"def new\n @entry_view = EntryView.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry_view }\n end\n end",
"def new\n @rss_feed = RssFeed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @rss_feed }\n end\n end",
"def create_feed\n @feed = Feed.new(params[:feed])\n\n respond_to do |format|\n if @feed.save\n EntryFeed.create_from_feed(@feed)\n format.html { redirect_to @feed, :notice => 'Feed was successfully created.' }\n format.json { render :json => @feed, :status => :created, :location => @feed }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @feed.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def new_rest\n @entry_item = EntryItem.new\n\n respond_to do |format|\n #format.html # new.html.erb\n format.xml { render :xml => @entry_item }\n end\n end",
"def new\n @entry = Entry.new\n \n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @entry }\n end\n end",
"def new\n @entry_type = EntryType.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry_type }\n end\n end",
"def create\n @feed = Feed.find(params[:feed_id])\n @entry = @feed.entries.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n @entry.author.save\n format.html { redirect_to feed_entry_path(@feed,@entry), notice: 'Entry was successfully created.' }\n format.json { render json: feed_entry_path(@feed, @entry), status: :created, location: feed_entry_path(@feed, @entry) }\n else\n format.html { render action: \"new\" }\n format.json { render json: feed_entry_path(@feed,@entry).errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @feed_element = FeedElement.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @feed_element }\n end\n end",
"def new\n @feed_category = FeedCategory.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @feed_category }\n end\n end",
"def new\n @entry = Entry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @entry }\n end\n end",
"def new\n @attachment = Attachment.new\n @entries = Entry.find(:all, :order => \"updated_at DESC\").map { |e| [e.title, e.id] }\n\n respond_to do |format|\n format.html\n format.xml { render :xml => @attachment }\n end\n end",
"def new\n @entry = Entry.new(project_id: @project.id, recorded_for: Date.today)\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def new\n @entry = Entry.new\n @folders = Folder.find(:all, :order => \"updated_at DESC\").map { |f| [f.name, f.id] }\n @new = true;\n\n respond_to do |format|\n format.html { render \"edit\" }\n format.xml { render :xml => @entry }\n end\n end",
"def new\n @timeentry = Timeentry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @timeentry }\n end\n end",
"def create\n @feed_entry = FeedEntry.new(params[:feed_entry])\n\n respond_to do |format|\n if @feed_entry.save\n format.html { redirect_to @feed_entry, notice: 'Feed entry was successfully created.' }\n format.json { render json: @feed_entry, status: :created, location: @feed_entry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @feed_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @entry = Entry.new(dob: Date.new(Date.today.year - 18, 1, 1))\n get_events\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @entry }\n end\n end",
"def show\n @feed = Feed.find(params[:id])\n @entries = EntryFeed.where(:feed_id => @feed.id)\n\n if @entries.blank?\n EntryFeed.create_from_feed(@feed)\n @entries = EntryFeed.where(:feed_id => @feed.id)\n end\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @feed }\n end\n end",
"def new\n @journal_entry = JournalEntry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @journal_entry }\n end\n end",
"def new\n @journal_entry = JournalEntry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @journal_entry }\n end\n end",
"def new\n @entry = Entry.new\n\n respond_to do |format|\n format.html # new.html.erb\n end\n end",
"def new\n @feed = Feed.new\n @page_title = 'Add Feed'\n\n respond_to do |format|\n format.html\n format.xml { render :xml => @feed }\n end\n end",
"def create\n url = params[:feed][:url]\n @feed = Feed.find_by_url(url) || Feed.new(url: url)\n @feed.fetch\n\n respond_to do |format|\n if @feed.save\n current_user.feeds << @feed unless current_user.feeds.include? @feed\n format.html { redirect_to @feed, notice: 'Feed was successfully added.' }\n format.json { render action: 'show', status: :created, location: @feed }\n else\n format.html { render action: 'new' }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @feedentry = Feedentry.new(params[:feedentry])\n\n respond_to do |format|\n if @feedentry.save\n format.html { redirect_to @feedentry, notice: 'Feedentry was successfully created.' }\n format.json { render json: @feedentry, status: :created, location: @feedentry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @feedentry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @twitterfeed = Twitterfeed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @twitterfeed }\n end\n end",
"def new\n @feed = Feed.new\n end",
"def new\n @feed = Feed.new\n end",
"def new\n @feed = Feed.new\n end",
"def new\n @feedbox = Feedbox.new\n #@feedbox.update_feed\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feedbox }\n end\n end",
"def create\n @feed_entry = FeedEntry.new(feed_entry_params)\n\n respond_to do |format|\n if @feed_entry.save\n format.html { redirect_to @feed_entry, notice: 'Feed entry was successfully created.' }\n format.json { render :show, status: :created, location: @feed_entry }\n else\n format.html { render :new }\n format.json { render json: @feed_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @time_entry = TimeEntry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @time_entry }\n end\n end",
"def new\n @time_entry = TimeEntry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @time_entry }\n end\n end",
"def new\n @time_entry = TimeEntry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @time_entry }\n end\n end",
"def create\n @feed = Feed.new(params[:feed])\n\n respond_to do |format|\n if @feed.save\n format.html { redirect_to @feed, notice: 'Feed was successfully created.' }\n format.json { render json: @feed, status: :created, location: @feed }\n else\n format.html { render action: \"new\" }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @entry = @resource_finder.new\n initialize_new_resource\n \n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @entry }\n end\n end",
"def new\n respond_to do |format|\n format.html # new.html.haml\n format.json { render :json => @news_item }\n end\n end",
"def new\n @feed_entry = FeedEntry.new\n @project = Project.find(params[:project_id])\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @feed_entry }\n end\n end",
"def new\n @recent_activity = RecentActivity.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @recent_activity }\n end\n end",
"def new\n @journal_entry = JournalEntry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @journal_entry }\n format.xml { render :xml => @journal_entry }\n end\n end",
"def new\n @feed_dislike = FeedDislike.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed_dislike }\n end\n end",
"def new\n @feedstock = Feedstock.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feedstock }\n end\n end",
"def new\n @published = Published.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @published }\n end\n end",
"def new\n @entry = Entry.new(\n :simple_text => true,\n :body => '',\n :locale => params[:locale],\n :tag_id => params[:tag_id] || session[:workspace_tag_id],\n :merge_to_id => params[:entry] && params[:entry]['merge_to_id']\n )\n if params[:master].present?\n master = Entry.find(params[:master])\n @entry = master.tidy_dup\n @entry.master_entry = master\n elsif params[:newsletter]\n @newsletter = Newsletter.find(params[:newsletter])\n @entry.tag = @newsletter.tag\n end\n \n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @entry }\n end\n end",
"def new\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @gl_entry = GlEntry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @gl_entry }\n end\n end",
"def new\n @update = Update.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @update }\n end\n end",
"def new\n @news_post = NewsPost.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @news_post }\n end\n end",
"def new\n @news_post = NewsPost.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @news_post }\n end\n end",
"def new\n @tweet = Tweet.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @tweet }\n end\n end",
"def new\n @tweet = Tweet.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @tweet }\n end\n end",
"def new\n @homepageentry = Homepageentry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @homepageentry }\n end\n end",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to new_entry_path, notice: \"Entry #{@entry} was successfully created.\" }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { get_events\n render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @datafeed = Datafeed.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @datafeed }\n end\n end",
"def new\n @update = Update.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @update }\n end\n end",
"def new\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @news_post }\n end\n end",
"def new\n post = Post.new\n render json: post\n end",
"def create\n @entry = current_user.entries.build(entry_params)\n if @entry.save\n flash[:success] = \"Entry created!\"\n redirect_to root_url\n else\n @feed_items = []\n render 'static_pages/home'\n end\n end",
"def new_rest\n @entry_answer = EntryAnswer.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @entry_answer }\n end\n end",
"def create\n @feed = Feed.new(feed_params)\n\n respond_to do |format|\n if @feed.save\n parse_entries\n format.html { \n redirect_to @feed\n flash[:success] = 'Feed was successfully created.' \n }\n format.js {}\n format.json { render :show, status: :created, location: @feed }\n else\n format.html { render :new }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n \n end",
"def new\n @populate_feed_info = PopulateFeedInfo.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @populate_feed_info }\n end\n end",
"def new\n \n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render :json => @post }\n end\n end",
"def new\n @newspost = Newspost.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @newspost }\n end\n end",
"def create\n\t\t@newEntry = Note.create(title: params[:title], entry: params[:entry], topic: params[:topic])\n\t\t@allNotes = Note.all\n\t\trender json: @allNotes\n\tend",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to entries_path, notice: 'Entry was successfully created.' }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n KyuEntry.invalid_attachments\n @kyu_entry = KyuEntry.new\n new_kyu = render_to_string(partial: \"newentry\",\n locals: {kyu_entry: @kyu_entry})\n respond_to do |format|\n format.json { render json: new_kyu.to_json }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n \n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def create\n @feed = Feed.new(feed_params)\n\n respond_to do |format|\n if @feed.save\n format.html { redirect_to @feed, notice: 'Feed was successfully created.' }\n format.json { render :show, status: :created, location: @feed }\n else\n format.html { render :new }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @moment_entry = MomentEntry.new\n @aircraft = Aircraft.find params[:aircraft_id]\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @moment_entry }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end",
"def new\n @post = Post.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @post }\n end\n end"
] |
[
"0.81818604",
"0.79339516",
"0.7641211",
"0.7641211",
"0.7641211",
"0.7641211",
"0.7585719",
"0.7567555",
"0.75592077",
"0.75592077",
"0.75592077",
"0.75592077",
"0.75592077",
"0.75592077",
"0.75592077",
"0.75592077",
"0.7367382",
"0.72282284",
"0.7134517",
"0.7098455",
"0.70505357",
"0.7041159",
"0.69973457",
"0.6945919",
"0.69448644",
"0.69209284",
"0.69180113",
"0.68717194",
"0.6869111",
"0.6860919",
"0.68559206",
"0.6850414",
"0.6814223",
"0.67820275",
"0.677901",
"0.6761149",
"0.6761149",
"0.675133",
"0.6742852",
"0.6716505",
"0.6701502",
"0.67000973",
"0.6663141",
"0.6663141",
"0.6663141",
"0.6654534",
"0.6638535",
"0.6617325",
"0.6617325",
"0.6617325",
"0.66125333",
"0.6610385",
"0.66019666",
"0.65870714",
"0.65725714",
"0.65652174",
"0.65377843",
"0.65241563",
"0.6501297",
"0.6498291",
"0.6498257",
"0.64961684",
"0.6494309",
"0.64885503",
"0.64885503",
"0.64726436",
"0.64726436",
"0.64704525",
"0.6466895",
"0.6456588",
"0.64539015",
"0.6453372",
"0.645193",
"0.64452046",
"0.6437465",
"0.642821",
"0.6422592",
"0.6419643",
"0.6414695",
"0.6410589",
"0.63989186",
"0.63872343",
"0.63789517",
"0.63787925",
"0.6378239",
"0.63782257",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126",
"0.6378126"
] |
0.791516
|
2
|
POST /feed_entries POST /feed_entries.json
|
def create
@feed_entry = FeedEntry.new(params[:feed_entry])
respond_to do |format|
if @feed_entry.save
format.html { redirect_to @feed_entry, notice: 'Feed entry was successfully created.' }
format.json { render json: @feed_entry, status: :created, location: @feed_entry }
else
format.html { render action: "new" }
format.json { render json: @feed_entry.errors, status: :unprocessable_entity }
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def create\n @feed = Feed.find(params[:feed_id])\n @entry = @feed.entries.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n @entry.author.save\n format.html { redirect_to feed_entry_path(@feed,@entry), notice: 'Entry was successfully created.' }\n format.json { render json: feed_entry_path(@feed, @entry), status: :created, location: feed_entry_path(@feed, @entry) }\n else\n format.html { render action: \"new\" }\n format.json { render json: feed_entry_path(@feed,@entry).errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_feed\n @feed = Feed.new(params[:feed])\n\n respond_to do |format|\n if @feed.save\n EntryFeed.create_from_feed(@feed)\n format.html { redirect_to @feed, :notice => 'Feed was successfully created.' }\n format.json { render :json => @feed, :status => :created, :location => @feed }\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @feed.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @feed_entry = FeedEntry.new(feed_entry_params)\n\n respond_to do |format|\n if @feed_entry.save\n format.html { redirect_to @feed_entry, notice: 'Feed entry was successfully created.' }\n format.json { render :show, status: :created, location: @feed_entry }\n else\n format.html { render :new }\n format.json { render json: @feed_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @feed = Feed.find(params[:feed_id])\n @entry = @feed.entries.new\n respond_to do |format|\n format.html { render :layout => 'feed'}\n format.json { render json: @entry }\n end\n end",
"def add_entries(entries, entry_id)\n entries.each do |entry|\n data = ::RssFeedDatum.where(url: entry.url).first_or_create(rss_feed_keyword_id: entry_id, guid: entry.id, name: entry.title, published_at: entry.published, blurb: get_html_content(\"#{entry.url}\"))\n end\n end",
"def show\n @feed = Feed.find(params[:id])\n @entries = EntryFeed.where(:feed_id => @feed.id)\n\n if @entries.blank?\n EntryFeed.create_from_feed(@feed)\n @entries = EntryFeed.where(:feed_id => @feed.id)\n end\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @feed }\n end\n end",
"def create\n @feedentry = Feedentry.new(params[:feedentry])\n\n respond_to do |format|\n if @feedentry.save\n format.html { redirect_to @feedentry, notice: 'Feedentry was successfully created.' }\n format.json { render json: @feedentry, status: :created, location: @feedentry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @feedentry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @feed = Feed.new(feed_params)\n\n respond_to do |format|\n if @feed.save\n parse_entries\n format.html { \n redirect_to @feed\n flash[:success] = 'Feed was successfully created.' \n }\n format.js {}\n format.json { render :show, status: :created, location: @feed }\n else\n format.html { render :new }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n \n end",
"def create\n @entry = current_user.entries.build(entry_params)\n if @entry.save\n flash[:success] = \"Entry created!\"\n redirect_to root_url\n else\n @feed_items = []\n render 'static_pages/home'\n end\n end",
"def entries_to_http entries, url, http = Atom::HTTP.new\n coll = Atom::Collection.new url, http\n\n entries.each { |entry| coll.post! entry }\n end",
"def create_entries(opts = {})\n data, _status_code, _headers = create_entries_with_http_info(opts)\n data\n end",
"def create\n @entry = Entry.new(entry_params)\n if @entry.valid?\n @entry.save\n render json: @entry, status: :created\n # , location: @entry\n else\n render json: @entry.errors, status: :unprocessable_entity\n end\n end",
"def entry_params\n params.require(:entry).permit(:feed_id, :atom_id, :title, :url, :content)\n end",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @current_user.entries << @entry\n format.html { redirect_to user_entries_path, notice: 'Entry was successfully created.' }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def save\n self.client.api_post(\"/feed\", self.create_params)\n end",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to entries_path, notice: 'Entry was successfully created.' }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = current_user.entries.build(entry_params)\n if @entry.save\n render json: EntrySerializer.new(@entry), status: :created\n else\n render json: { error: @entry.errors.full_messages.to_sentence}, status: :unprocessable_entity\n end\n end",
"def create\n @entry = Entry.new({\n content: params[:entry][:content],\n journal_id: params[:entry][:journal_id]\n })\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to \"/entries/#{@entry.id}\" }\n format.json { render :show }\n else\n format.html { render :new }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_entries(feed_entries)\n guids = entries.map(&:guid)\n feed_entries.reject {|e| guids.include? e.id}.each do |entry|\n entry.sanitize!\n entries.add(entry)\n end\n end",
"def entry_params\n params.require(:entry).permit(:title, :url, :content, :image, :feed_id)\n end",
"def index\n @feed_entries = FeedEntry.all\n end",
"def create_feed\n end",
"def create_feed\n end",
"def create_feed\n end",
"def create_feed\n end",
"def create\n\n @entry = Entry.new(entry_params)\n\n respond_to do |format|\n\n if @entry.save\n format.html { redirect_to entries_path, notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: @entry }\n else\n @today_entries = Entry.where(\"date = ?\", Date.today)\n @yesterday_entries = Entry.where(\"date = ?\", Date.yesterday)\n format.html { render :action => :index }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @feed_entry = FeedEntry.new(params[:feed_entry])\n\n respond_to do |format|\n if @feed_entry.save\n flash[:notice] = 'FeedEntry was successfully created.'\n format.html { redirect_to(@feed_entry) }\n format.xml { render :xml => @feed_entry, :status => :created, :location => @feed_entry }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @feed_entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def feed_entry_params\n params.require(:feed_entry).permit(:feed_id, :title, :url, :published_at, :image_url, :summary, :original_id)\n end",
"def create\n @entry = Entry.new(entry_params)\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: @entry }\n else\n format.html { render :new }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, notice: 'Entry was successfully created.' }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, notice: 'Entry was successfully created.' }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, notice: 'Entry was successfully created.' }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n require 'feedzirra'\n feed = parse_feed params[:new_podcast_url]\n feed.sanitize_entries! # let's make sure this actually makes things usable'\n\n # Make the podcast entry\n @podcast = Podcast.new(\n :title => feed.title,\n :url => params[:new_podcast_url]\n )\n\n if @podcast.save\n feed.entries.each do |entry|\n song = Song.new(\"title\" => entry.title, \"location\" => entry.url, \"artist\" => entry.author, \"album\" => feed.title)\n song.audio = @podcast\n song.save! # TODO add exception handling\n end\n end\n\n respond_to do |format|\n if @podcast.blank?\n format.json { render json: @podcast.songs.to_json }\n format.html { redirect_to :songs_dashboard, notice: 'Podcast was successfully created.' }\n else\n format.json { render json: @podcast.errors }\n format.html { render action: \"new\" }\n end\n end\n end",
"def create\n @entry = current_user.entries.new(entry_params)\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, notice: 'Your entry has been posted!' }\n format.json { render action: 'show', status: :created, location: @entry }\n else\n format.html { render action: 'new' }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(entry_params)\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, notice: 'Entry was successfully created.' }\n format.json { render action: 'show', status: :created, location: @entry }\n else\n format.html { render action: 'new' }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def judging_feed \n challenges = CsApi::Judging.queue(current_access_token)\n\n @feed_items = Array.new \n @feed_title = 'CloudSpokes Judging Queue'\n\n unless challenges.nil? \n challenges.each do |challenge|\n entry = AtomEntryJudging.new(:id => challenge['id'], :title => challenge['name'], :end_date => challenge['end_date'], \n :due_date => challenge['winner_announced'], :categories => challenge['challenge_categories__r'])\n @feed_items.push(entry)\n end\n end\n\n respond_to do |format|\n format.atom { render :layout => false }\n # we want the RSS feed to redirect permanently to the ATOM feed\n format.rss { redirect_to judging_feed_path(:format => :atom), :status => :moved_permanently }\n end\n\n end",
"def posts\n posts = @client.entries(content_type: 'post').items\n posts || []\n end",
"def new\n @feedentry = Feedentry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feedentry }\n end\n end",
"def new\n @feed_entry = FeedEntry.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @feed_entry }\n end\n end",
"def entry_params\n payload = params.require(:payload).permit(:data_url, :event_date, :event_url, :feed_url)\n {\n feed: Feed.friendly.find(params[:feed_id]),\n source_url: payload['data_url'],\n event_at: payload['event_date']\n # title: params[:entry][:event_date]\n }\n end",
"def build_post_from_entry(entry)\n text = entry.text.gsub(/\\\\u([0-9a-zA-Z]{4})/) { |s| [$1.to_i(16)].pack(\"U\") }\n self.posts.build(\n :service_action => Service::SERVICE_ACTION_POST,\n :identifier => entry.id.to_s,\n :title => text,\n :markup => Post::HTML_MARKUP,\n :summary => text,\n :url => \"#{self.profile_url}/status/#{entry.id}\",\n :published_at => entry.created_at.to_time,\n :extra_content => {\n :original_tags => self.search_for_hashtags(text) # array de tags\n }\n )\n end",
"def create\n @feed = Feed.new(params[:feed])\n\n respond_to do |format|\n if @feed.save\n format.html { redirect_to @feed, notice: 'Feed was successfully created.' }\n format.json { render json: @feed, status: :created, location: @feed }\n else\n format.html { render action: \"new\" }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def entries\n Entry.where(:feed_id => pk)\n end",
"def entries\n uri = URI(BASE_URL + ENTRIES_ENDPOINT + days_query)\n\n make_request(uri)\n end",
"def feed\n @feed_items = @repository.recent_feed_items\n respond_to do |format|\n format.html # feed.html.erb\n format.json { render json: @feed_items }\n end\n end",
"def create\n @entry = Entry.new(entry_params)\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: @entry }\n else\n format.html { render :new }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def build_post_from_entry(entry, action)\n date = if (action == Service::SERVICE_ACTION_POST) || (self.posts.count == 0)\n entry[:pubDate]\n else\n Time.current\n end\n\n self.posts.build(\n :summary => (entry[:description].blank? ? '-' : entry[:description]),\n :service_action => action,\n :identifier => entry[:guid].to_s,\n :title => entry[:title],\n :markup => Post::PLAIN_MARKUP,\n :url => entry[:link],\n :published_at => date,\n :extra_content => {\n :author_name => entry[:author_name],\n :original_tags => entry[:categories] # array de tags\n }\n )\n end",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to new_entry_path, notice: \"Entry #{@entry} was successfully created.\" }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { get_events\n render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def build_post_from_entry(entry)\n self.posts.build(\n :summary => entry[:description],\n :service_action => Service::SERVICE_ACTION_POST,\n :identifier => entry[:guid].to_s,\n :title => entry[:title],\n :markup => Post::PLAIN_MARKUP,\n :url => entry[:link],\n :published_at => entry[:pubDate]\n )\n end",
"def create_entries_with_http_info(opts = {})\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: EntriesApi.create_entries ...'\n end\n # resource path\n local_var_path = '/api/v1/entries'\n\n # query parameters\n query_params = opts[:query_params] || {}\n\n # header parameters\n header_params = opts[:header_params] || {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['*/*'])\n # HTTP header 'Content-Type'\n header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])\n\n # form parameters\n form_params = opts[:form_params] || {}\n\n # http body (model)\n post_body = opts[:debug_body] || @api_client.object_to_http_body(opts[:'create_entries_input'] || opts[:body])\n\n # return_type\n return_type = opts[:debug_return_type] || 'Entry'\n\n # auth_names\n auth_names = opts[:debug_auth_names] || ['authToken']\n\n new_options = opts.merge(\n :operation => :\"EntriesApi.create_entries\",\n :header_params => header_params,\n :query_params => query_params,\n :form_params => form_params,\n :body => post_body,\n :auth_names => auth_names,\n :return_type => return_type\n )\n\n data, status_code, headers = @api_client.call_api(:POST, local_var_path, new_options)\n if @api_client.config.debugging\n @api_client.config.logger.debug \"API called: EntriesApi#create_entries\\nData: #{data.inspect}\\nStatus code: #{status_code}\\nHeaders: #{headers}\"\n end\n return data, status_code, headers\n end",
"def create\n @entry = Entry.new(entry_params)\n respond_to do |format|\n if @entry.save\n format.html { redirect_to [@blog, @entry], notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: [@blog, @entry] }\n else\n format.html { render :new }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n params[:entry].delete(\"freigeschaltet\")\n @entry = Entry.new(entry_params)\n @entry.user = current_user unless @entry.user_id.present?\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, notice: 'Eintrag erfolgreich erstellt.' }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n\n end",
"def index\n #body, ok = SuperfeedrEngine::Engine.retrieve(Feed.first) \n @entries = Entry.all\n end",
"def create\n @entry = Entry.new(entry_params)\n @entry['user_id'] = current_user.id\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: @entry }\n else\n format.html { render :new }\n format.json { render json: @entry.errors.full_messages, status: :unprocessable_entity }\n end\n end\n end",
"def fetch!\n parsed_feed = FeedNormalizer::FeedNormalizer.parse open(self.feed_url)\n \n self.update_attributes( :title => parsed_feed.title,\n :url => parsed_feed.url\n #:etag => parsed_feed.etag\n #:last_modified => parsed_feed.last_modified\n )\n \n parsed_feed.entries.each do |entry|\n self.entries.create(:url => entry.url,\n :title => entry.title,\n :author => entry.author,\n #:summary => entry.summary,\n :content => entry.content\n #:published => entry.published\n #:categories => entry.categories\n ) if !Entry.find_by_url(entry.url)\n end\n end",
"def create\n url = params[:feed][:url]\n @feed = Feed.find_by_url(url) || Feed.new(url: url)\n @feed.fetch\n\n respond_to do |format|\n if @feed.save\n current_user.feeds << @feed unless current_user.feeds.include? @feed\n format.html { redirect_to @feed, notice: 'Feed was successfully added.' }\n format.json { render action: 'show', status: :created, location: @feed }\n else\n format.html { render action: 'new' }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def fetch_and_save_entries\n create_entries_from(parse_feed_content)\n rescue => e\n raise unless Rails.env.production?\n\n Rails.logger.error e\n end",
"def feed_params\n params.require(:feed).permit(:user_id, :feed_name, :feed_url, :feed_entries, :tag_list)\n end",
"def create\n @entry = current_user.entries.build(entry_params)\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to entries_path, notice: 'Entry was successfully created.' }\n format.json { render action: 'show', status: :created, location: @entry }\n else\n format.html { render action: 'new' }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\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 entries=(new_entries)\n for entry in new_entries\n unless entry.kind_of? FeedTools::FeedItem\n raise ArgumentError,\n \"You should only add FeedItem objects to the entries array.\"\n end\n end\n @entries = new_entries\n end",
"def post(opts = {})\n return ':data argument not provided' unless opts[:data]\n \n type = opts[:type] || Names::AtomEntryMediaType\n @invoker = Poster.new(@uri, @authent)\n @invoker['Slug'] = opts[:slug] if opts[:slug]\n \n if @invoker.post(type, opts[:data]) \n @invoker.entry \n else\n @invoker.last_error \n end\n end",
"def feed_entries(feed, include_read: false, page: nil)\n EntriesPagination.feed_entries feed, self, include_read: include_read, page: page\n end",
"def create\n logger.info \"Creating Entry\"\n @entry = Entry.new(params[:entry])\n logger.info \"Entry Created\"\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to(entries_url, :notice => 'Entry was successfully created.') }\n format.xml { render :xml => @entry, :status => :created, :location => @entry }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @feed = Feed.new(feed_params)\n\n respond_to do |format|\n if @feed.save\n format.html { redirect_to @feed, notice: 'Feed was successfully created.' }\n format.json { render :show, status: :created, location: @feed }\n else\n format.html { render :new }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n puts \"In entries#create, params=#{params}\"\n entity_id = params[:entity_id]\n=begin\n @entity = Entity.find(entity_id)\n template_name = @entity.template.name\n\n @entry = EntryManager.initialize_entry(@entity)\n=end\n @entity = Entity.find(entity_id)\n @entry = Entry.new({:entity_id => entity_id})\n \n @context = {:display_mode => 'new' \n }\n \n template = \"/templates/predefined/#{@entity.template.name}.html.erb\"\n entry_html = render_to_string(:template=>template, \n :layout=>false,\n )\n\n \n @entry[:html] = entry_html\n @entry[:attr_values] = @entry.attr_values\n @entry[:attrs] = @entity.attrs\n\n render :json => {\n :entry => @entry\n\n }\n end",
"def create\n @entry = Entry.new(entry_params)\n #binding.pry\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: @entry }\n else\n format.html { render :new }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n attachment = params[:kyu_entry].delete :attachment\n params[:kyu_entry].merge!(user_id: current_user.id)\n params[:kyu_entry].merge!(publish_at: Time.now)\n kyu_entry = KyuEntry.new(params[:kyu_entry])\n # kyu_entry.set_user_and_publish_date(current_user)\n respond_to do |format|\n if kyu_entry.save\n attachments = params[:attachments_field].split(\",\")\n unless attachments.blank?\n attachments.each do |attachment|\n kyu_entry.attachments << Attachment.find(attachment)\n end\n end\n new_entry = render_to_string(partial: \"entries\",\n locals: { kyu_entry: kyu_entry })\n sidebar = render_to_string( partial: \"sidebar\",\n locals: { tag_cloud_hash: tag_cloud, users: @users})\n format.json { render json: { new_entry: new_entry, sidebar: sidebar } }\n else\n format.json { render json: kyu_entry.errors,\n status: :unprocessable_entity}\n end\n end\n end",
"def create\n if params[:newsletter_id]\n nl = SemiStatic::Newsletter.find(params[:newsletter_id])\n @entry = nl.tag.entries.build(entry_params)\n @entry.save\n nl.add_entry(@entry, true)\n else\n @entry = Entry.new(entry_params)\n end\n\n respond_to do |format|\n if params[:convert]\n format.js { render 'convert'}\n elsif @entry.save\n expire_page_cache(@entry)\n if params[:newsletter_id]\n format.html { redirect_to edit_newsletter_path(params[:newsletter_id]) }\n else\n format.html { redirect_to entries_path(:anchor => \"entry_id_#{@entry.merged_main_entry.id}\", :page => page(@entry.merged_main_entry)) }\n format.json { render :json => @entry, :status => :created, :location => @entry }\n end\n else\n format.html { render :action => \"new\" }\n format.json { render :json => @entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @feed = Feed.new(feed_params)\n\n respond_to do |format|\n if @feed.save\n format.html { redirect_to authenticated_root_path, notice: 'Feed was successfully created.' }\n format.json { render :show, status: :created, location: @feed }\n else\n format.html { render :new }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(params[:entry])\n respond_to do |format|\n if @entry.save\n format.html { redirect_to @entry, :notice => 'Entry was successfully created.' }\n format.json { render :json => @entry, :status => :created, :location => @entry }\n else\n @clients = Client.all.collect{ |c| [c.name, c.id] }\n @aircraft_types = AircraftType.all(:order => :name).collect{|c| [c.name, c.id]}\n \n format.html { render :action => \"new\" }\n format.json { render :json => @entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n \n @entry = Entry.new(params[:entry])\n @entry.date = Date.strptime(params[:entry][:date], '%m/%d/%Y')\n \n respond_to do |format|\n if @entry.save\n format.html { redirect_to manage_entry_path( @entry ), notice: 'Entry was successfully created.' }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n\n end",
"def create\n @content_entry = Content::Entry.new(content_entry_params)\n\n respond_to do |format|\n if @content_entry.save\n format.html { redirect_to @content_entry, notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: @content_entry }\n else\n format.html { render :new }\n format.json { render json: @content_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def entries\n if @entries.nil?\n raw_entries = FeedTools::XmlHelper.select_not_blank([\n FeedTools::XmlHelper.try_xpaths_all(self.channel_node, [\n \"atom10:entry\",\n \"atom03:entry\",\n \"atom:entry\",\n \"entry\"\n ]),\n FeedTools::XmlHelper.try_xpaths_all(self.root_node, [\n \"rss10:item\",\n \"rss11:items/rss11:item\",\n \"rss11:items/item\",\n \"items/rss11:item\",\n \"items/item\",\n \"item\",\n \"atom10:entry\",\n \"atom03:entry\",\n \"atom:entry\",\n \"entry\",\n \"story\"\n ]),\n FeedTools::XmlHelper.try_xpaths_all(self.channel_node, [\n \"rss10:item\",\n \"rss11:items/rss11:item\",\n \"rss11:items/item\",\n \"items/rss11:item\",\n \"items/item\",\n \"item\",\n \"story\"\n ])\n ])\n\n # create the individual feed items\n @entries = []\n unless raw_entries.blank?\n for entry_node in raw_entries.reverse\n new_entry = FeedItem.new\n new_entry.feed_data = entry_node.to_s\n new_entry.feed_data_type = self.feed_data_type\n new_entry.root_node = entry_node\n if new_entry.root_node.namespace.blank?\n new_entry.root_node.add_namespace(self.root_node.namespace)\n end\n @entries << new_entry\n end\n end\n end\n \n # Sort the items\n if self.configurations[:entry_sorting_property] == \"time\"\n @entries = @entries.sort do |a, b|\n (b.time or Time.utc(1970)) <=> (a.time or Time.utc(1970))\n end\n elsif self.configurations[:entry_sorting_property] != nil\n sorting_property = self.configurations[:entry_sorting_property]\n @entries = @entries.sort do |a, b|\n eval(\"a.#{sorting_property}\") <=> eval(\"b.#{sorting_property}\")\n end\n else\n return @entries.reverse\n end\n return @entries\n end",
"def create\n @entry = Entry.new(entry_params)\n @entry.user_id = current_user.id\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to root_url, notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: @entry }\n else\n format.html { render :new }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n if params[:type] == \"create\"\n entry = Entry.new(entry_params)\n if entry.save\n entry.async_fetch\n end\n end\n render json: {success: true}, status: 200\n end",
"def feed\n @posts = Post.feed_of(params[:id])\n end",
"def index\n @entries = Entry\n .paginate(:page => params[:page], :per_page => 10)\n .find_all_by_entry_type(params[:entry_type].presence || 'post', :include => :user)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @entries }\n end\n end",
"def create\n cite_key = params['entry']['cite_key']\n category = params['entry']['category']\n clean_params = EntryValidator.clean_params category, params\n @entry = Entry.new(category:category, cite_key:cite_key)\n entry_valid = EntryValidator.validate @entry, clean_params\n\n respond_to do |format|\n if entry_valid and @entry.save and create_fields(clean_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: @entry }\n else\n @fields = get_fields\n format.html { render :new_thing }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def test_can_post_valid_entry\n valid_entry = SEED_ENTRIES.first\n post_json '/api/entries', valid_entry.except(:slug)\n\n assert last_response.created?\n\n location = \"/api/entries/#{valid_entry[:slug]}\"\n assert last_response.headers['Location'] = location\n assert last_response.headers['Content-Location'] = location\n\n parsed_resp = parse_json_resp(last_response)\n assert_instance_of Hash, parsed_resp\n assert_equal valid_entry[:word], parsed_resp['word']\n assert_equal valid_entry[:definition], parsed_resp['definition']\n assert_equal location, parsed_resp['location']\n end",
"def create\n\n @entry = Entry.new(entry_params)\n @entry.blog_id = params[:blog_id]\n @entry.save\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to blog_entries_url, notice: 'Entry was successfully created.' }\n format.json { render action: 'show', status: :created, location: blog_entries_url }\n else\n format.html { render action: 'new' }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(entry_params)\n\n respond_to do |format|\n if @entry.save\n @stuffs = Stuff.ordered\n format.html { redirect_to entries_url, notice: 'Entrada criada com sucesso!' }\n format.json { render :show, status: :created, location: @entry }\n format.js\n else\n @stuff = Stuff.find(params[\"entry\"][\"stuff_id\"])\n format.js { render :new }\n end\n end\n end",
"def create\n @data_entry = DataEntry.new(data_entry_params)\n\n respond_to do |format|\n if @data_entry.save\n format.html { redirect_to @data_entry, notice: 'Data entry was successfully created.' }\n format.json { render :show, status: :created, location: @data_entry }\n else\n format.html { render :new }\n format.json { render json: @data_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @feed_item = FeedItem.new(feed_item_params)\n\n respond_to do |format|\n if @feed_item.save\n format.json { render :show, status: :created, location: @feed_item }\n else\n format.json { render json: @feed_item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to [:admin, @entry], notice: 'Entry was successfully created.' }\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to(:action => :index, :notice => 'Entry was successfully created.') }\n format.xml { render :xml => @entry, :status => :created, :location => @entry }\n else\n format.html do\n @entries = Entry.find_all_by_time params[:date]\n render :action => \"index\"\n end\n format.xml { render :xml => @entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(entry_params)\n @entry.user = User.find_by name: session[:user]\n @entry.likes = 0\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to entries_url, notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: @entry }\n else\n format.html { render :new }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @entry = Entry.new(entry_params)\n\n flash[:notice] = 'Entry was successfully created.' if @entry.save\n respond_with(@entry)\n end",
"def create\n @entry = Entry.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to(@entry, :notice => 'Entry was successfully created.') }\n format.xml { render :xml => @entry, :status => :created, :location => @entry }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n tag_group_id = params[:feed][:tag_group_id]\n @tag_group = TagGroup.find_by_id tag_group_id\n\n @feed = @tag_group.feeds.create(params[:feed])\n\n respond_to do |format|\n if @feed.save\n format.html { redirect_to @tag_group, notice: 'Feed was successfully created.' }\n format.json { render json: @feed, status: :created, location: @feed }\n else\n format.html { render action: \"new\" }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @entry = Entry.new\n\n render json: @entry\n end",
"def post(message)\n OAuth2::AccessToken.new(OAuthClient, token).post('/me/feed', :message => message)\n end",
"def feed_params\n params.require(:feed).permit(:feed_text, :date, :feed_image)\n end",
"def create\n @entry = @time_sheet.entries.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n # [@user, @time_sheet, @entry]\n # user_time_sheet_entries_path(@user, @time_sheet)\n format.html { redirect_to user_time_sheet_entries_path(@user, @time_sheet), notice: 'Hours were successfully added.' }\n format.json { render json: [@user, @time_sheet, @entry], status: :created, location: [@user, @time_sheet, @entry] }\n else\n format.html { render action: \"new\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def save_dictionary_entries(dictionary, dictionary_entries, opts = {})\n response = @transporter.write(\n :POST,\n path_encode('/1/dictionaries/%s/batch', dictionary),\n { clearExistingDictionaryEntries: false, requests: chunk('addEntry', dictionary_entries) },\n opts\n )\n\n DictionaryResponse.new(self, response)\n end",
"def create\n # @entry = Entry.new(entry_params)\n ep = entry_params\n\n if ( ep[:category_id] == nil && params[:new_category_name] != '' )\n new_category = current_user.categories.new(:name => params[:new_category_name])\n new_category.save\n\n ep[:category_id] = new_category.id\n\n p ep[:category_id]\n end\n\n @entry = current_user.entries.build(ep)\n\n respond_to do |format|\n if @entry.save\n format.html { redirect_to root_path, notice: 'Entry created.' }\n format.json { render action: 'show', status: :created, location: root_path }\n else\n format.html { redirect_to root_path }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n\t\t@newEntry = Note.create(title: params[:title], entry: params[:entry], topic: params[:topic])\n\t\t@allNotes = Note.all\n\t\trender json: @allNotes\n\tend",
"def posts_feed\n\n init_posts_feed\n\n end",
"def create\n @entry = Entry.new(entry_params)\n @dictionary = Dictionary.find(params[:dictionary_id])\n respond_to do |format|\n if @entry.save\n format.html { redirect_to dictionary_entry_path(@dictionary, @entry),\n notice: 'Entry was successfully created.' }\n format.json { render :show, status: :created, location: @entry }\n else\n format.html { render :new }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create_feed(feed_id, feed_name = nil)\n feed = create_blueprint\n feed[:id] = feed_id\n feed[:name] = feed_name\n\n begin\n return http_post('/feeds/', feed)\n rescue HawkularException => error\n # 409 We already exist -> that is ok\n if error.status_code == 409\n the_feed = hawk_escape_id feed_id\n http_get(\"/feeds/#{the_feed}\")\n else\n raise\n end\n end\n end"
] |
[
"0.71177864",
"0.6742121",
"0.6672325",
"0.6662345",
"0.66572225",
"0.6586359",
"0.6571794",
"0.6541356",
"0.6541065",
"0.64221865",
"0.63847136",
"0.63748074",
"0.6251975",
"0.61803406",
"0.6178804",
"0.61771166",
"0.6169259",
"0.6151998",
"0.6145556",
"0.6129383",
"0.6123749",
"0.61212313",
"0.61212313",
"0.61212313",
"0.61212313",
"0.61180943",
"0.60780156",
"0.6072957",
"0.6056157",
"0.60470176",
"0.60470176",
"0.60470176",
"0.6029123",
"0.6023536",
"0.59984374",
"0.5995472",
"0.5990019",
"0.5980112",
"0.5975869",
"0.59535265",
"0.5951329",
"0.59485215",
"0.5948078",
"0.59432834",
"0.5929579",
"0.5927769",
"0.5900162",
"0.58974856",
"0.5887101",
"0.58820295",
"0.5876633",
"0.58744717",
"0.5873287",
"0.58707756",
"0.5868408",
"0.5862397",
"0.5860195",
"0.58597237",
"0.58579266",
"0.58439726",
"0.5835737",
"0.58243984",
"0.5824229",
"0.5818981",
"0.5815199",
"0.58134186",
"0.5797962",
"0.5792662",
"0.5772216",
"0.5757902",
"0.57412505",
"0.5740123",
"0.57386774",
"0.57377315",
"0.5732291",
"0.5726818",
"0.57230496",
"0.5698293",
"0.5652219",
"0.56482065",
"0.5640517",
"0.5639882",
"0.56387794",
"0.56358933",
"0.5635765",
"0.5634505",
"0.5620468",
"0.5612383",
"0.5606752",
"0.56025636",
"0.5600061",
"0.55973476",
"0.55955124",
"0.55911624",
"0.55889726",
"0.5586882",
"0.55857766",
"0.5583258",
"0.55823886",
"0.5579394"
] |
0.6662979
|
3
|
PUT /feed_entries/1 PUT /feed_entries/1.json
|
def update
@feed_entry = FeedEntry.find(params[:id])
respond_to do |format|
if @feed_entry.update_attributes(params[:feed_entry])
format.html { redirect_to @feed_entry, notice: 'Feed entry was successfully updated.' }
format.json { head :no_content }
else
format.html { render action: "edit" }
format.json { render json: @feed_entry.errors, status: :unprocessable_entity }
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def update\n @entry = Entry.find(params[:id])\n @feed = @entry.feed\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to feed_entry_path(@feed, @entry), notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n @feed = @entry.feed\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to feed_entry_path(@feed, @entry), notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.json { render json: @entry, status: :created, location: @entry }\n else\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @feed_entry.update(feed_entry_params)\n format.html { redirect_to @feed_entry, notice: 'Feed entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @feed_entry }\n else\n format.html { render :edit }\n format.json { render json: @feed_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n if @entry.update_attributes(params[:entry])\n head :no_content\n else\n render json: @entry.errors, status: :unprocessable_entity\n end\n end",
"def update\n @feedentry = Feedentry.find(params[:id])\n\n respond_to do |format|\n if @feedentry.update_attributes(params[:feedentry])\n format.html { redirect_to @feedentry, notice: 'Feedentry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @feedentry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @feed = Feed.find(params[:id])\n\n respond_to do |format|\n if @feed.update_attributes(params[:feed])\n format.html { redirect_to @feed, :notice => 'Feed was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @feed.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @feed = Feed.find(params[:feed_id])\n @entry = @feed.entries.new(params[:entry])\n\n respond_to do |format|\n if @entry.save\n @entry.author.save\n format.html { redirect_to feed_entry_path(@feed,@entry), notice: 'Entry was successfully created.' }\n format.json { render json: feed_entry_path(@feed, @entry), status: :created, location: feed_entry_path(@feed, @entry) }\n else\n format.html { render action: \"new\" }\n format.json { render json: feed_entry_path(@feed,@entry).errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n feed = Feed.find(params[:id])\n if feed.update_attributes(feed_params)\n render :json => {:ok => true}, :head => :no_content\n else\n render :json => {:ok => false, :message => feed.errors}, :status => :unprocessable_entity\n end\n end",
"def update\n @feed = Feed.find(params[:id])\n\n respond_to do |format|\n if @feed.update_attributes(params[:feed])\n format.html { redirect_to @feed, notice: 'Feed successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @feed = Feed.find(params[:id])\n\n respond_to do |format|\n if @feed.update_attributes(params[:feed])\n format.html { redirect_to @feed, notice: 'Feed updated OK' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @feed = Feed.find(params[:id])\n\n respond_to do |format|\n if @feed.update_attributes(params[:feed])\n format.html { redirect_to @feed, notice: 'Feed was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @feed = Feed.find(params[:id])\n\n respond_to do |format|\n if @feed.update_attributes(params[:feed])\n format.html { redirect_to @feed, notice: 'Feed was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @feed = Feed.find(params[:id])\n\n respond_to do |format|\n if @feed.update_attributes(params[:feed])\n format.html { redirect_to root_path, notice: 'Feed was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @feed_entry = FeedEntry.find(params[:id])\n\n respond_to do |format|\n if @feed_entry.update_attributes(params[:feed_entry])\n flash[:notice] = 'FeedEntry was successfully updated.'\n format.html { redirect_to(@feed_entry) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @feed_entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def put_atom_entry(entry, url = entry.edit_url)\n raise \"Cowardly refusing to PUT a non-Atom::Entry (#{entry.class})\" unless entry.is_a? Atom::Entry\n headers = {\"Content-Type\" => \"application/atom+xml\" }\n\n put(url, entry.to_s, headers)\n end",
"def update\n respond_to do |format|\n if @feed.update(feed_params)\n format.html { redirect_to @feed, notice: 'Feed was successfully updated.' }\n format.json { render :show, status: :ok, location: @feed }\n else\n format.html { render :edit }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @feed.update(feed_params)\n format.html { redirect_to @feed, notice: 'Feed was successfully updated.' }\n format.json { render :show, status: :ok, location: @feed }\n else\n format.html { render :edit }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @feed.update(feed_params)\n format.html { redirect_to @feed, notice: 'Feed was successfully updated.' }\n format.json { render :show, status: :ok, location: @feed }\n else\n format.html { render :edit }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @feed.update(feed_params)\n format.html { redirect_to @feed, notice: 'Feed was successfully updated.' }\n format.json { render :show, status: :ok, location: @feed }\n else\n format.html { render :edit }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @feed.update(feed_params)\n format.html { redirect_to @feed, notice: 'Feed was successfully updated.' }\n format.json { render :show, status: :ok, location: @feed }\n else\n format.html { render :edit }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @feed.update(feed_params)\n format.html { redirect_to authenticated_root_path, notice: 'Feed was successfully updated.' }\n format.json { render :show, status: :ok, location: @feed }\n else\n format.html { render :edit }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def show\n @feed = Feed.find(params[:id])\n @entries = EntryFeed.where(:feed_id => @feed.id)\n\n if @entries.blank?\n EntryFeed.create_from_feed(@feed)\n @entries = EntryFeed.where(:feed_id => @feed.id)\n end\n\n respond_to do |format|\n format.html # show.html.erb\n format.json { render :json => @feed }\n end\n end",
"def set_feed_entry\n @feed_entry = FeedEntry.find(params[:id])\n end",
"def update\n @feed = Feed.find(params[:id])\n\n if @feed.update_attributes(params[:feed])\n redirect_to @feed, notice: 'Feed was successfully updated.'\n else\n render action: \"edit\"\n end\n end",
"def update(feed, options = {})\n body = options.has_key?(:body) ? options[:body] : {}\n body[:feed] = feed\n\n response = @client.put \"/api/topics/#{@topic_id}/feeds/#{@id}\", body, options\n\n return response\n end",
"def update\n @entry = Entry.find(params[:id])\n params[:entry][:status] = 'publish' if params[:entry][:status] == 'update'\n \n if params[:entry][:entry_metas_attributes].present?\n params[:entry][:entry_metas_attributes].replace(convert_entry_metas_attributes(params[:entry][:entry_metas_attributes]))\n end\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to edit_admin_entry_path(@entry), notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @feed.update(feed_params)\n format.html { \n redirect_to @feed\n flash[:success] = 'Feed was successfully updated.' \n }\n format.json { render :show, status: :ok, location: @feed }\n else\n format.html { render :edit }\n format.json { render json: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @feed = Feed.find(params[:id])\n\n respond_to do |format|\n if @feed.update_attributes(params[:feed])\n flash[:notice] = 'Feed was successfully updated.'\n format.html { redirect_to feed_url(@feed) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @feed.errors.to_xml }\n end\n end\n end",
"def update!(**args)\n @entries = args[:entries] if args.key?(:entries)\n @kind = args[:kind] if args.key?(:kind)\n end",
"def update_rest\n @entry_item = EntryItem.find(params[:id])\n\n respond_to do |format|\n if @entry_item.update_attributes(params[:entry_item])\n flash[:notice] = 'EntryItem was successfully updated.'\n #format.html { redirect_to(@entry_item) }\n format.xml { head :ok }\n else\n #format.html { render :action => \"edit\" }\n format.xml { render :xml => @entry_item.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @entries = args[:entries] if args.key?(:entries)\n end",
"def update!(**args)\n @entries = args[:entries] if args.key?(:entries)\n end",
"def update!(**args)\n @entries = args[:entries] if args.key?(:entries)\n end",
"def update\n @twitterfeed = Twitterfeed.find(params[:id])\n\n respond_to do |format|\n if @twitterfeed.update_attributes(params[:twitterfeed])\n flash[:notice] = 'Twitterfeed was successfully updated.'\n format.html { redirect_to(@twitterfeed) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @twitterfeed.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @feed = current_user.feeds.find params[:id]\n current_user.refresh_feed @feed\n\n head :ok\n rescue => e\n handle_error e\n end",
"def update\n respond_to do |format|\n if @feed_item.update(feed_item_params)\n format.json { render :show, status: :ok, location: @feed_item }\n else\n format.json { render json: @feed_item.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to blog_entries_url, notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to entries_path, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to entries_path, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = FeedEntry.find(params[:id])\n\n tags = params['tags' + params[:id]]\n\n respond_to do |format|\n if FeedEntry.add_tag(@entry, tags)\n format.html {render action: 'index'}\n format.json {head :no_content}\n else\n format.html {render action: 'index'}\n format.json {render json: @entry.errors, status: :unprocessable_entity}\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors.full_messages, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to edit_entry_path(@entry), notice: 'Entry updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update!(**args)\n @feed = args[:feed] if args.key?(:feed)\n @id = args[:id] if args.key?(:id)\n @label_bucket = args[:label_bucket] if args.key?(:label_bucket)\n @label_value = args[:label_value] if args.key?(:label_value)\n @name = args[:name] if args.key?(:name)\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to entries_path, notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(entry_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_entry\n if params[:id].present?\n if params[:id] == 'current'\n @feed = Feed.friendly.find(params[:feed_id])\n @entry = @feed.entries.recent.first\n else\n @entry = Entry.friendly.find(params[:id])\n end\n end\n end",
"def update\n respond_to do |format|\n\n if @entry.update(entry_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to @entry, notice: 'Entry was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to :back, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @feed = Feed.find(params[:feed_id])\n @entry = @feed.entries.new\n respond_to do |format|\n format.html { render :layout => 'feed'}\n format.json { render json: @entry }\n end\n end",
"def update\n respond_to do |format|\n if @task_entry.update(task_entry_params)\n format.json { head :no_content }\n else\n format.json { render json: @task_entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @feed_info.update(feed_info_params)\n format.html { redirect_to @feed_info, notice: 'Feed info was successfully updated.' }\n format.json { render :show, status: :ok, location: @feed_info }\n else\n format.html { render :edit }\n format.json { render json: @feed_info.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @feed.attributes = params[:feed]\n\n respond_to do |format|\n if @feed.save(user: current_user)\n format.html { render 'admin/shared/update' }\n format.xml { head :ok }\n else\n @feed.reload # to retrieve the old title\n format.html { render template: 'admin/shared/edit', locals: { record: @feed }, status: :unprocessable_entity }\n format.xml { render xml: @feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to root_url, notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to @entry, notice: 'Your entry was successfully updated sir.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n # format.json { render json: @event.errors, status: :unprocessable_entity }\n end\n end\n end",
"def fetch!\n parsed_feed = FeedNormalizer::FeedNormalizer.parse open(self.feed_url)\n \n self.update_attributes( :title => parsed_feed.title,\n :url => parsed_feed.url\n #:etag => parsed_feed.etag\n #:last_modified => parsed_feed.last_modified\n )\n \n parsed_feed.entries.each do |entry|\n self.entries.create(:url => entry.url,\n :title => entry.title,\n :author => entry.author,\n #:summary => entry.summary,\n :content => entry.content\n #:published => entry.published\n #:categories => entry.categories\n ) if !Entry.find_by_url(entry.url)\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to(entries_url, :notice => 'Entry was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @rss_feed = RssFeed.find(params[:id])\n\n respond_to do |format|\n if @rss_feed.update_attributes(params[:rss_feed])\n format.html { redirect_to '/', notice: 'Rss feed was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @rss_feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @rss_feed = RssFeed.find(params[:id])\n\n respond_to do |format|\n if @rss_feed.update_attributes(params[:rss_feed])\n format.html { redirect_to @rss_feed, notice: 'Rss feed was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @rss_feed.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n flash[:success] = \"Entry updated\"\n format.html { redirect_to edit_entry_path }\n else\n format.html { redirect_to edit_entry_path }\n end\n end\n end",
"def update\n @entry = @current_user.entries.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to user_entries_path, notice: 'Entry was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to [@blog, @entry], notice: 'Entry was successfully updated.' }\n format.json { render :show, status: :ok, location: [@blog, @entry] }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def entry_params\n params.require(:entry).permit(:feed_id, :atom_id, :title, :url, :content)\n end",
"def update!(**args)\n @entrys = args[:entrys] unless args[:entrys].nil?\n @kind = args[:kind] unless args[:kind].nil?\n end",
"def update\n @feed = Feed.find(params[:id])\n\n respond_to do |format|\n if @feed.update_attributes(params[:feed])\n flash[:notice] = 'Feed was successfully updated.'\n format.html { redirect_to( user_feeds_path(@user) ) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @feed.errors }\n end\n end\n end",
"def feed_entry_params\n params.require(:feed_entry).permit(:feed_id, :title, :url, :published_at, :image_url, :summary, :original_id)\n end",
"def update!(**args)\n @entries = args[:entries] if args.key?(:entries)\n @next_page_token = args[:next_page_token] if args.key?(:next_page_token)\n end",
"def update!(**args)\n @entries = args[:entries] if args.key?(:entries)\n @next_page_token = args[:next_page_token] if args.key?(:next_page_token)\n end",
"def update_from_feed(auth_feed=nil)\n # If there are existing entries, then create a feed \n # object using the most recent entry's data and use Feedzirra's update method\n # to only fetch those new entries\n if entries.any?\n feed = Feedzirra::Feed.update(create_feed_for_update)\n add_entries(feed.new_entries) if valid_parse_result(feed) && !feed.is_a?(Array) && feed.updated?\n else\n # Fetch whole feed (may not be entire feed - depends on source)\n feed = auth_feed || Feedzirra::Feed.fetch_and_parse(feed_url_s)\n # Can return error status code on parse error\n add_entries(feed.entries) if valid_parse_result(feed)\n end\n # Save latest feed attributes for updates\n if valid_parse_result(feed)\n update_attributes(:etag => feed.etag, :last_modified => feed.last_modified, :feed_url_s => feed.feed_url)\n end\n end",
"def update(url, data)\n RestClient.put url, data, :content_type => :json\nend",
"def update\r\n @feed = Feed.find(params[:id])\r\n @feeds = current_user.feeds\r\n if @feed.update_attributes(params[:feed])\r\n flash[:notice] = \"Feed successfully updated\"\r\n else\r\n flash[:error] = \"Feed update failed\"\r\n end\r\n \r\n respond_to do |format|\r\n format.html { redirect_to feeds_path }\r\n format.js {render :layout => false}\r\n end\r\n end",
"def update\n @feed_element = FeedElement.find(params[:id])\n\n respond_to do |format|\n if @feed_element.update_attributes(params[:feed_element])\n format.html { redirect_to @feed_element, :notice => 'Feed element was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @feed_element.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to(:action => :index, :notice => 'Entry was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @feed = Feed.find(params[:id]) rescue Feed.find_by_uri(params[:id])\n \n respond_to do |wants|\n if @feed.update_attributes(params[:feed])\n wants.xml { render :nothing => true }\n wants.js\n else\n wants.xml { render :xml => @feed.errors.to_xml }\n wants.js\n end\n end\n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n flash[:notice] = 'Entry was successfully updated.'\n format.html { redirect_to(@entry) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @entry_set = EntrySet.find(params[:id])\n @entry_set.update_attributes(params[:entry_set])\n\n render 'show'\n \n end",
"def update\n @entry = Entry.find(params[:id])\n\n respond_to do |format|\n if @entry.update_attributes(params[:entry])\n format.html { redirect_to(@entry, :notice => 'Entry was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def set_entry\n @entry = Entry.find(params[:id])\n end",
"def set_entry\n @entry = Entry.find(params[:id])\n end",
"def set_entry\n @entry = Entry.find(params[:id])\n end",
"def entry_params\n params.require(:entry).permit(:title, :url, :content, :image, :feed_id)\n end",
"def update\n @entry = Entry.find(params[:id])\n respond_to do |format|\n if @entry.update({\n content: params[:entry][:content],\n journal_id: params[:entry][:journal_id]\n })\n format.html { redirect_to @entry }\n format.json { render :show }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @event_entry = EventEntry.find(params[:id])\n\n respond_to do |format|\n if @event_entry.update_attributes(params[:event_entry])\n format.html { redirect_to @event_entry, :notice => 'Event entry was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.json { render :json => @event_entry.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @datafeed = Datafeed.find(params[:id])\n\n respond_to do |format|\n if @datafeed.update_attributes(params[:datafeed])\n flash[:notice] = 'Datafeed was successfully updated.'\n format.html { redirect_to(@datafeed) }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @datafeed.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update \n respond_to do |format|\n if @entry.update(entry_params)\n format.html { redirect_to link_entries_path(@link), notice: 'Entry was successfully updated.' }\n format.js { redirect_to link_entries_path(@link)}\n format.json { render :show, status: :ok, location: @entry }\n else\n format.html { render :edit }\n format.json { render json: @entry.errors, status: :unprocessable_entity }\n end\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @feed = @entry.feed\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to feed_path(@feed) }\n format.json { head :no_content }\n end\n end",
"def set_json_entry\n @json_entry = JsonEntry.find(params[:id])\n end"
] |
[
"0.7246307",
"0.7246307",
"0.70268375",
"0.6814572",
"0.6733385",
"0.6701174",
"0.6678864",
"0.66784394",
"0.666431",
"0.6620534",
"0.6612091",
"0.6603729",
"0.6603729",
"0.6593721",
"0.65492576",
"0.6521436",
"0.64245814",
"0.64245814",
"0.64245814",
"0.64245814",
"0.64245814",
"0.63943636",
"0.6389717",
"0.6370496",
"0.6338899",
"0.6317674",
"0.6310506",
"0.6307548",
"0.6286162",
"0.6280492",
"0.62531245",
"0.6219038",
"0.6219038",
"0.6219038",
"0.62115204",
"0.62002563",
"0.619845",
"0.61965686",
"0.6189144",
"0.6187117",
"0.6187117",
"0.6181957",
"0.6181957",
"0.6177349",
"0.6168531",
"0.6166976",
"0.6165477",
"0.6165477",
"0.6165477",
"0.61653495",
"0.61653495",
"0.61653495",
"0.61653495",
"0.61653495",
"0.61653495",
"0.61444074",
"0.61380905",
"0.6135557",
"0.6132288",
"0.6131225",
"0.6123744",
"0.6120652",
"0.61204076",
"0.6118959",
"0.6096194",
"0.6089525",
"0.60848796",
"0.607871",
"0.60772747",
"0.60651624",
"0.60349274",
"0.60220927",
"0.6021256",
"0.60183215",
"0.601672",
"0.6012414",
"0.6008597",
"0.6007409",
"0.59947574",
"0.5989183",
"0.5989183",
"0.59837395",
"0.59627956",
"0.5955757",
"0.59418714",
"0.5936815",
"0.5934882",
"0.5933647",
"0.5931687",
"0.59316766",
"0.59162223",
"0.59162223",
"0.59162223",
"0.5912242",
"0.59025025",
"0.58870363",
"0.5885929",
"0.58770525",
"0.5871018",
"0.58626795"
] |
0.6841135
|
3
|
DELETE /feed_entries/1 DELETE /feed_entries/1.json
|
def destroy
@feed_entry = FeedEntry.find(params[:id])
@feed_entry.destroy
respond_to do |format|
format.html { redirect_to feed_entries_url }
format.json { head :no_content }
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def destroy\n @entry = Entry.find(params[:id])\n @feed = @entry.feed\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to feed_path(@feed) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feedentry = Feedentry.find(params[:id])\n @feedentry.destroy\n\n respond_to do |format|\n format.html { redirect_to feedentries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed_entry.destroy\n respond_to do |format|\n format.html { redirect_to feed_entries_url, notice: 'Feed entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed_item.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed_entry = FeedEntry.find(params[:id])\n @feed_entry.destroy\n\n respond_to do |format|\n format.html { redirect_to(feed_entries_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n debugger\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to blog_entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n Feed.find(params[:id]).destroy\n render :json => {:ok => true}, :head => :no_content\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @entry = Entry.find_by_id(params[:id])\n @entry.destroy if @entry\n\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @feed = Feed.find(params[:id])\n @feed.destroy\n\n respond_to do |format|\n format.html { redirect_to feeds_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed = Feed.find(params[:id])\n @feed.destroy\n\n respond_to do |format|\n format.html { redirect_to feeds_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed = Feed.find(params[:id])\n @feed.destroy\n\n respond_to do |format|\n format.html { redirect_to feeds_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed = Feed.find(params[:id])\n @feed.destroy\n\n respond_to do |format|\n format.html { redirect_to feeds_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to '/entries' }\n format.json { render json: @entry }\n end\n end",
"def destroy_rest\n @entry_item = EntryItem.find(params[:id])\n @entry_item.destroy\n\n respond_to do |format|\n #format.html { redirect_to(entry_items_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @post_entry.destroy\n respond_to do |format|\n format.html { redirect_to post_entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to root_path }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to root_path }\n format.json { head :no_content }\n end\n end",
"def destroy\n @r_entry.destroy\n respond_to do |format|\n format.html { redirect_to r_entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to(entries_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to(entries_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to(entries_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to(entries_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to(entries_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @entry ||= Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to(entries_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n head :no_content\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to manage_entries_path }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed_item = FeedItem.find(params[:id])\n @feed_item.destroy\n\n respond_to do |format|\n format.html { redirect_to feed_items_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to entries_url, :notice => \"Entry has been deleted\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to entries_url, notice: \"Eintrag erfolgreich gelöscht. #{undo_link}\" }\n format.json { head :no_content }\n end\n end",
"def destroy\n current_user.user_feeds.find_by_feed_id(params[:id]).destroy\n respond_to do |format|\n format.html { redirect_to feeds_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed.destroy\n respond_to do |format|\n format.html { redirect_to feeds_url, notice: 'Feed was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed.destroy\n respond_to do |format|\n format.html { redirect_to feeds_url, notice: 'Feed was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed.destroy\n respond_to do |format|\n format.html { redirect_to feeds_url, notice: 'Feed was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed.destroy\n respond_to do |format|\n format.html { redirect_to feeds_url, notice: 'Feed was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed.destroy\n respond_to do |format|\n format.html { redirect_to feeds_url, notice: 'Feed was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.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 @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry = current_user.entries.find(params[:id])\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @rss_feed = RssFeed.find(params[:id])\n @rss_feed.destroy\n\n respond_to do |format|\n format.html { redirect_to rss_feeds_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @rss_feed = RssFeed.find(params[:id])\n @rss_feed.destroy\n\n respond_to do |format|\n format.html { redirect_to rss_feeds_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed_url.destroy\n respond_to do |format|\n format.html { redirect_to feed_urls_url, notice: 'Feed url was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete_entries(entries)\n delete_all(:id => entries)\n end",
"def destroy\n @feed = Feed.find(params[:id])\n @feed.destroy\n\n respond_to do |format|\n format.html { redirect_to feeds_url }\n format.xml { head :ok }\n end\n end",
"def destroy\n @feed_item.destroy\n respond_to do |format|\n format.html {redirect_to feed_items_url, notice: 'Feed item was successfully destroyed.'}\n format.json {head :no_content}\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to [@project, :entries] }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :no_content }\n format.js\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to root_url, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed_info.destroy\n respond_to do |format|\n format.html { redirect_to feed_infos_url, notice: 'Feed info was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @mypost = Mypost.find(params[:id])\n @mypost.destroy\n\t\n\n respond_to do |format|\n format.html { redirect_to myfeed_path }\n format.json { head :no_content }\n end\n\t\t end",
"def delete\n client.delete(\"/#{id}\")\n end",
"def destroy\n @entry_set = EntrySet.find(params[:id])\n @entry_set.destroy\n\n respond_to do |format|\n format.html { redirect_to entry_sets_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @news_feed.destroy\n\n respond_to do |format|\n format.html { redirect_to news_feeds_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @twitterfeed = Twitterfeed.find(params[:id])\n @twitterfeed.destroy\n\n respond_to do |format|\n format.html { redirect_to(twitterfeeds_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n RestClient.delete \"#{REST_API_URI}/contents/#{id}.xml\" \n self\n end",
"def destroy\n @fud_entry.destroy\n respond_to do |format|\n format.html { redirect_to fud_entries_url, notice: 'Fud entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed.destroy\n respond_to do |format|\n format.html { \n redirect_to feeds_url\n flash[:success] = 'Feed was successfully destroyed.' \n }\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed_element = FeedElement.find(params[:id])\n @feed_element.destroy\n\n respond_to do |format|\n format.html { redirect_to feed_elements_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @event_entry = EventEntry.find(params[:id])\n @event_entry.destroy\n\n respond_to do |format|\n format.html { redirect_to event_entries_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to @blog, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def test_valid_delete_returns_204\n db = DB.get\n\n valid_entry = SEED_ENTRIES.first\n insert_entry(db, valid_entry)\n\n assert_equal 1, db.execute('select * from entries').count\n\n delete \"/api/entries/#{valid_entry[:slug]}\"\n assert last_response.no_content?\n\n assert_equal 0, db.execute('select * from entries').count\n end",
"def destroy\n @datafeed = Datafeed.find(params[:id])\n @datafeed.destroy\n\n respond_to do |format|\n format.html { redirect_to(datafeeds_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n collection = Collection.find(@mlog_entry[:collection_id])\n @mlog_entry.destroy\n respond_to do |format|\n format.html { redirect_to collection}\n format.json { head :no_content }\n end\n end",
"def delete_feed(feed_id)\n the_feed = hawk_escape_id feed_id\n http_delete(\"/feeds/#{the_feed}\")\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to redirect_path, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @kyu_entry.destroy\n respond_to do |format|\n format.html { redirect_to kyu_entries_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n redirect_to(entries_url)\n end",
"def destroy\n @entry = Entry.find(params[:id])\n entry_type = @entry.entry_type\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to admin_entries_url(:entry_type => entry_type)}\n format.json { head :no_content }\n end\n end",
"def destroy\n @feed = Feed.find(params[:id])\n @feed.destroy\n redirect_to feeds_url\n end",
"def destroy\n @timeentry = Timeentry.find(params[:id])\n @timeentry.destroy\n\n respond_to do |format|\n format.html { redirect_to timeentries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @data_entry.destroy\n respond_to do |format|\n format.html { redirect_to data_entries_url, notice: 'Data entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @task_entry.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry_view = EntryView.find(params[:id])\n @entry_view.destroy\n\n respond_to do |format|\n format.html { redirect_to entry_views_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to dictionary_entries_url(@dictionary),\n notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @populate_feed_info = PopulateFeedInfo.find(params[:id])\n @populate_feed_info.destroy\n\n respond_to do |format|\n format.html { redirect_to(populate_feed_infos_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @logentry.destroy\n respond_to do |format|\n format.html { redirect_to logentries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @homepageentry = Homepageentry.find(params[:id])\n @homepageentry.destroy\n\n respond_to do |format|\n format.html { redirect_to homepageentries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @entry.destroy\n respond_to do |format|\n format.html { redirect_to @goal, notice: 'Entry was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @journal_entry = JournalEntry.find(params[:id])\n @journal_entry.destroy\n\n respond_to do |format|\n format.html { redirect_to(journal_entries_url) }\n format.json { render :json => [] }\n format.xml { head :ok }\n end\n end",
"def destroy\n @time_entry = TimeEntry.with_deleted.find(params[:id])\n @time_entry.destroy\n\n respond_to do |format|\n format.html { redirect_to time_entries_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @log_entry = LogEntry.find(params[:id])\n @log_entry.destroy\n\n respond_to do |format|\n format.html { redirect_to log_entries_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @feed_list.destroy\n respond_to do |format|\n format.html { redirect_to feed_lists_url, notice: 'Feed list was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n if @feed.user_id == current_user.id\n @feed.destroy\n respond_to do |format|\n format.html { redirect_to feeds_url }\n format.json { head :no_content }\n end\n else\n err_mex\n end\n end",
"def destroy\n \n \tredirect_to root_url unless is_moderator(current_user)\n @entry = Entry.find(params[:id])\n @entry.destroy\n\n respond_to do |format|\n format.html { redirect_to entries_url }\n format.json { head :no_content }\n end\n end"
] |
[
"0.7675228",
"0.7567747",
"0.7458496",
"0.7410145",
"0.7379684",
"0.7348866",
"0.7295838",
"0.7239369",
"0.7239369",
"0.72324055",
"0.7209484",
"0.72024554",
"0.72024554",
"0.72024554",
"0.71721816",
"0.7163158",
"0.7163158",
"0.7163158",
"0.7163036",
"0.7148303",
"0.714283",
"0.7126833",
"0.71137697",
"0.71137697",
"0.7092502",
"0.7081945",
"0.7081945",
"0.7081945",
"0.7081945",
"0.7081945",
"0.7075553",
"0.7049058",
"0.7047467",
"0.7032476",
"0.6992131",
"0.6947541",
"0.6941274",
"0.69223356",
"0.69156194",
"0.69156194",
"0.69156194",
"0.69156194",
"0.69156194",
"0.6910659",
"0.69073087",
"0.69073087",
"0.69073087",
"0.69073087",
"0.69073087",
"0.69073087",
"0.69073087",
"0.69073087",
"0.69073087",
"0.69073087",
"0.68837345",
"0.68671334",
"0.68671334",
"0.6865112",
"0.68642086",
"0.68554556",
"0.68493074",
"0.68477434",
"0.6831266",
"0.6829005",
"0.6823489",
"0.68149805",
"0.6811653",
"0.6807825",
"0.6804177",
"0.67886686",
"0.67849505",
"0.6776641",
"0.6775194",
"0.6774916",
"0.67718697",
"0.676977",
"0.6763026",
"0.67564166",
"0.6745192",
"0.6733945",
"0.6731012",
"0.67123085",
"0.6711633",
"0.67106044",
"0.66735804",
"0.6673233",
"0.66686165",
"0.6666314",
"0.66662836",
"0.6664382",
"0.6662838",
"0.66609126",
"0.6652361",
"0.6640865",
"0.6640298",
"0.6637572",
"0.6633593",
"0.6623405",
"0.6614525",
"0.6613953"
] |
0.76343584
|
1
|
Details: Your car is old, it breaks easily. The shock absorbers are gone and you think it can handle about 15 more bumps before it dies totally. Unfortunately for you, your drive is very bumpy! Given a string showing either flat road ("_") or bumps ("n"), work out if you make it home safely. 15 bumps or under, return "Woohoo!", over 15 bumps return "Car Dead".
|
def bump(x)
x.count('n') <= 15 ? "Woohoo!" : "Car Dead"
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def hamstrings_stretch\n \"Remaining seated, extend one leg outward. Reach toward your toes. Hold for 10 to 30 seconds. Repeat on the other side. Be sure to do this one leg at a time, as doing this exercise with both legs out can cause back issues.\"\nend",
"def catch_phrase\n [\n [\"ninja\",\"master\",\"student\"].rand, \n [\"\", \"\", \"\", \"\", \"\", \"\", \"weapons\", \"s' 3rd annual\",\"s' 5th annual\",\"s' 10th annual\", \"s' secret\"].rand,\n [\"gathering\",\"celebration\",\"meeting\",\"tournament\",\"competition\",\"party\",\"training camp\",\"sparring event\"].rand,\n [\"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"\", \"with Leonardo\", \"with Raphael\", \"with Michaelangelo\", \"with Donatello\"].rand\n ].join(' ').gsub(/ s\\'/,'s\\'').gsub(/\\s\\s/,' ').strip\n end",
"def offer_rose (string)\r\n \"Would you take this rose, #{string}, in exchange for giving an old beggar woman shelter from the bitter cold?\" \r\nend",
"def cooking\n \"Grab the butter, we're about to be cookin.\"\nend",
"def dynamic_phrase_4\r\n\r\n # Verse 1: **no more bottles**\r\n if one_bottle?\r\n \"no more bottles\"\r\n # Verse 0: **99 bottles**\r\n elsif zero_bottles?\r\n \"99 #{bottle_s}\"\r\n else\r\n # Verse 2: **bottle**\r\n # Verse x: **x bottles**\r\n @bottle_quantity -= 1\r\n \"#{bottle_quantity} #{bottle_s}\"\r\n end\r\n end",
"def catch_phrase\n [\n [\"Фирма1\", \"Суперфирма\", \"Фирма3\", \"ПанСамСклепав\"].rand,\n [\"24 часа\", \"24/7\", \"круглосуточно\", \"3 года на рынке\"].rand,\n [\"доступно\", \"быстро\", \"надежно\"].rand\n ].join(' ')\n end",
"def pirates_say_arrrrrrrrr(string)\n other_word = \"\"\n string.length.times do | index |\n if ((string[index].downcase.include? \"r\") && (string[index + 1] != nil))\n other_word << string[index + 1]\n end\n end\n\n return other_word\nend",
"def set_counting_recommendation_strings\n @cold = \"The deck is cold. Play conservatively. There are more low cards than high cards. The dealer is less likely to bust, but so are you. Doubling down will be less useful. Blackjacks are less common.\"\n @warm = \"The deck is warm. There are more high cards than low cards. Blackjacks will be common. Doubling down when appropriate will be advantagous. The dealer is likely to bust.\"\n @hot = \"The deck is hot! Your biggest worry at this point is the dealer stealing your Blackjacks. This deck is stacked!\"\n end",
"def hey(string)\n if string.count(\"/A-Z/\") == 10 # Test 3\n p \"Whoa, chill out!\"\n elsif string[0] == \"T\" # Test one passes\n p \"Whatever.\"\n elsif string[0] == \"W\" && string[9] == \"!\" # Test 2\n p \"Whoa, chill out!\"\n elsif string[0] == \"D\" # Test 4\n p \"Sure.\"\n elsif string[0] == \"Y\" # Test 5\n p \"Sure.\"\n elsif string.count(\"/a-z/\") == 10 # Test 6\n p \"Sure.\"\n elsif string[0] == \"L\" # Test 7\n p \"Whatever.\"\n elsif string[0] == \"I\" && string[1] == \"t\" # Test 8\n p \"Whatever.\"\n elsif string[0] == \"W\" && string[31] == \"?\" # Test 9\n p \"Whoa, chill out!\"\n elsif string[0] == \"1\" && string[10] == \"!\" # Test 10\n p \"Whoa, chill out!\"\n elsif string[0] == \"1\" # Test 11\n p \"Whatever.\"\n elsif string[0] == \"4\" # Test 12\n p \"Sure.\"\n elsif string[0] == \"Z\" # Test 13\n p \"Whoa, chill out!\"\n elsif string[2] == \"H\" # Test 14\n p \"Whoa, chill out!\"\n elsif string[0] == \"E\" # Test 15\n p \"Whatever.\"\n elsif string[4] == \"!\" # Test 16\n p \"Sure.\"\n elsif string == \"\" # Test 17\n p \"Fine. Be that way!\"\n elsif string[0] == \" \" # Test 18\n p \"Fine. Be that way!\"\n elsif string[0] == \"\\t\" # Test 19\n p \"Fine. Be that way!\"\n elsif string[1] == \"D\" # Test 20\n p \"Whatever.\"\n end\n end",
"def mercedes\n woo(\"It turns out to be a self-driving car and drops you off at home.\")\nend",
"def charm_failure\n slowly do\n\"\"\"\nDuncan barks, wags his tail, rolls over, does all his awesome tricks...\n\nBut the troll just looks on in disdain. \n\n'Go home, little dog, before I sqquish you.' \n\"\"\"\n end\n what_next\n end",
"def bear_roars()\n return \"RROOOAAAAARRRRR\"\nend",
"def dynamic_phrase_2\r\n # Verse 0: **no more bottles**\r\n if zero_bottles?\r\n \"no more #{bottle_s}\"\r\n else\r\n # Verse 1: **1 bottle**\r\n # Verse x: **x bottles**\r\n \"#{bottle_quantity} #{bottle_s}\"\r\n end\r\n end",
"def bump(x)\n # return \"Card Dead\" if x.chars.count(\"n\") > 15 else \"Woohoo!\"\n x.chars.count(\"n\") > 15 ? \"Car Dead\" : \"Woohoo!\"\nend",
"def awesomesauce_infusion(strings)\n i = 0\n infused_strings = []\n strings.length.times do\n infused_strings << strings[i]\n if i < strings.length - 1\n infused_strings << \"awesomesauce\"\n end\n i += 1\n end\n return infused_strings\nend",
"def get_a_sample_note\n Card[\"Death Star uses dark side of the Force\"]\nend",
"def dynamic_phrase_3\r\n one_it = 'one'\r\n\r\n # Verse 0: **Go to the store and buy some more**\r\n if zero_bottles?\r\n 'Go to the store and buy some more'\r\n else\r\n # Verse 1: **it**\r\n if one_bottle?\r\n one_it = 'it'\r\n end\r\n # Verse x: **Take one down and pass it around**\r\n \"Take #{one_it} down and pass it around\"\r\n end\r\n end",
"def get_word_for_print(letters, good_letters)\n result = ''\n letters.each do |item|\n result += if good_letters.include?(item)\n item + ' '\n else\n '__ '\n end\n end\n result\n end",
"def cracklepop1\n def aux x\n /[A-Z]+/i.match(x.to_s).to_s\n end\n (1..100).map do |i|\n x = i%3==0 ? 'crackle' : i\n i%5==0 ? (aux(x)+'pop') : x\n end\nend",
"def pirates_say_arrrrrrrrr(string)\nz = \"\"\nstring.split(\"\").each_index{|x| z << string[x+1] if string.downcase[x] == \"r\" && string[x+1] != nil }\nz\nend",
"def solution(string)\n # lowers = string.scan(/[a-z]+[A-Z]/).join\n uppers = string.scan(/[A-Z][^A-Z]+/).join(' ')\n # lowers + \" \" + uppers\n # require 'pry'; binding.pry\n\nend",
"def dynamic_phrase_1\r\n\r\n # Verse 1: **1 bottle**\r\n # Verse 0: **No more bottles**\r\n if zero_bottles?\r\n \"No more bottles\"\r\n # Verse 1: **1 bottle**\r\n # Verse x: **x bottles**\r\n else\r\n \"#{bottle_quantity} #{bottle_s}\"\r\n end\r\n end",
"def verse(number)\n case number\n when 0\n \"No more bottles of beer on the wall, \" +\n \"no more bottles of beer.\\n\" +\n \"Go to the store and buy some more, \" +\n \"99 bottles of beer on the wall.\\n\"\n else\n \"#{number} bottles of beer on the wall, \" +\n \"#{number} bottles of beer.\\n\" +\n \"Take #{pronoun(number)} down and pass it around, \" +\n \"#{quantity(number - 1)} #{container(number - 1)} of beer on the wall.\\n\"\n end\nend",
"def phrase(str)\n puts \"#{str}..Only in America!\"\nend",
"def pirates_say_arrrrrrrrr(string)\n\nstring.downcase!\nsplitsplat = string.split(//)\nresult = \"\"\n\nsplitsplat.each_with_index do |l, index|\n if l == \"r\"\n result << splitsplat[index + 1].to_s\n end\nend\nreturn result\nend",
"def pirates_say_arrrrrrrrr(string)\n final_result = \"\"\n looking_for_r = false\n string.length.times do |x|\n if looking_for_r == true\n final_result << string[x]\n end\n looking_for_r = string[x].include?(\"r\") || string[x].include?(\"R\")\n end\n final_result\nend",
"def description_from_string(str)\n len = 12\n return str unless str.length > len\n \"#{str[0..len - 1]}...\" # Is this length correct?\n end",
"def verbose(card)\n suits = {H: 'Hearts', C: 'Clubs', D: 'Diamonds', S: 'Spades'}\n royals = {K: 'King', Q: 'Queen', J: 'Jack', A: 'Ace'}\n card_val = card[0..-2]\n card_suit = card[-1]\n card_suit = suits[card_suit.to_sym] # Converts abreviation to suit name.\n if card_val.to_i == 0 # checks for royals\n royal = royals[card_val.to_sym]\n \"#{royal} of #{card_suit}\"\n else # numerical cards\n \"#{card_val} of #{card_suit}\"\n end\nend",
"def tiy_fizz_buzz(string)\n special = (0..9).to_a + ('!'..'?').to_a\n arr = string.chars\n arr.map do |a|\n case\n when special.include?(a) == true\n a\n when \"AEIOU\".include?(a) == true\n a = \"Iron Yard\"\n when \"aeiou\".include?(a) == true\n a = \"Yard\"\n when \"BCDFGHJKLMNPQRSTVWXYZ\".include?(a) == true\n a = \"Iron\"\n else\n a\n end\n end.join(\"\")\nend",
"def breakfast(food=\"oatmeal\")\n \"The most important meal of the day could always be #{food}!\"\nend",
"def pirates_say_arrrrrrrrr(string)\n output = \"\"\n string.length.times do |index|\n output << string[index+1] if string[index].downcase == \"r\" && index < (string.length - 1)\n \n end\n return output\nend",
"def speak_to_grandma(takes_string_arguement)\n\n if takes_string_arguement == takes_string_arguement.upcase\n return \"NO, NOT SINCE 1938!\"\n else\n return \"HUH?! SPEAK UP, SONNY!\"\n end\n \nend",
"def get_quote(person)\n if person == 'Yoda'\n return 'Do. Or do not. There is no try.'\n end\n\n if person == 'Confucius'\n return 'I hear and I forget. I see and I remember. I do and I understand.'\n end\n\n if person == 'Einstein'\n return 'Do not worry about your difficulties in Mathematics. I can assure you mine are still greater.'\n end\nend",
"def get_quote(person)\n if person == 'Yoda'\n return 'Do. Or do not. There is no try.'\n end\n\n if person == 'Confucius'\n return 'I hear and I forget. I see and I remember. I do and I understand.'\n end\n\n if person == 'Einstein'\n return 'Do not worry about your difficulties in Mathematics. I can assure you mine are greater.'\n end\nend",
"def get_word_for_print(letters, good_letters)\n result = \"\"\n\n letters.each do |letter|\n result += if good_letters.include?(letter)\n letter + \" \"\n else\n \"_ \"\n end\n end\n\n result\n end",
"def pirates_say_arrrrrrrrr(string)\n #sort through letters in a string, return next letter\n array = string.split('')\n array.select.each_with_index do |item, index|\n if item == \"r\" \n array[index + 1].join\n else\n nil\n end\n end\nend",
"def do_adhoc(str)\n str.gsub!(/^\\\\cleardoublepage$/, \"\")\n str.gsub!(/^\\\\plainifnotempty$/, \"\")\n str.gsub!(/^\\\\small$/, \"\")\n str.gsub!(/^\\\\normalsize$/, \"\")\n str.gsub!(/^\\\\centering$/, \"\")\n\n # URL\n str.gsub!(/\\\\verb\\|(.+?)\\|/) do |m|\n s = $1\n if s =~ URI.regexp\n s\n else\n m\n end\n end\n\n text_pairs = {\n %! \\\\vspace*{-0.1\\\\Cvs}! => \"\",\n %!$10^{12} = 1 \\\\mathrm{TB}$! => %!@<raw>#{LBRACE}|html|10<sup>12</sup>#{RBRACE}=1TB!,\n %!$\\\\exists, \\\\forall$! => %!@<raw>#{LBRACE}|html|∃, ∀#{RBRACE}!,\n %!$\\\\lnot,\\\\land,\\\\lor$! => %!@<raw>#{LBRACE}|html|¬,∧,∨#{RBRACE}!,\n %!$>$! => %!@<raw>#{LBRACE}|html|>#{RBRACE}!,\n %!$<$! => %!@<raw>#{LBRACE}|html|<#{RBRACE}!,\n %!B$^+$! => %!@<raw>#{LBRACE}|html|B<sup>+</sup>#{RBRACE}!,\n %!\\\\paragraph{Step 4.} \\\\ ! => %!\\\\paragraph{Step 4.}!,\n %!\\\\verb|http://s2k-ftp.cs.berkeley.edu/ingres/|! => %!http://s2k-ftp.cs.berkeley.edu/ingres/!,\n %!\\\\verb|pc<code.size()|! => %!@<tt>#{LBRACE}pc<code.size()#{RBRACE}!,\n %!\\\\verb|c|! => %!@<tt>#{LBRACE}c#{RBRACE}!,\n %!\\\\verb|m|! => %!@<tt>#{LBRACE}m#{RBRACE}!,\n %!\\\\verb|z|! => %!@<tt>#{LBRACE}z#{RBRACE}!,\n %!$n$! => %!n!,\n %!$\\\\mathrm{O}(1)$! => %!O(1)!,\n %!$\\\\mathrm{O}(n)$! => %!O(n)!,\n %!$\\\\beta$! => %!@<raw>#{LBRACE}|html|β#{RBRACE}!,\n %!$t$! => %!t!,\n %![$^{11}$C]! => %!@<raw>#{LBRACE}|html|[<sup>11</sup>C]#{RBRACE}!,\n }\n\n text_pairs.each do |k,v|\n regex = Regexp.compile(Regexp.quote(k))\n str.gsub!(regex, v)\n end\n\n str.gsub!(/^\\s*\\\\begin\\{lstlisting\\}\\n((?:.|\\n)*?)\\n\\s*\\\\end\\{lstlisting\\}\\n/) do |m|\n \"//emlist{\\n\" + $1 + \"\\n//}\\n\"\n end\n\n str.gsub!(/^\\s*\\\\begin\\{quote\\}\\n((?:.|\\n)*?)\\n\\s*\\\\end\\{quote\\}\\n/) do |m|\n \"//quote{\\n\" + $1 + \"\\n//}\\n\"\n end\n\n str.gsub!(/^\\s*\\\\(begin|end)\\{(minipage|center|figure)\\}.*$/, \"\")\n\n img_refs = Hash.new\n str.gsub!(/^\\s*\\\\includegraphics(?:\\[.*?\\])?\\{(.+?)\\}[\\s\\n]*\\\\caption\\{(.+?)\\}[\\s\\n]*\\\\label\\{(.+?)\\}/) do |m|\n imgfile = $1.strip\n caps = $2.strip\n label = $3.strip\n if imgfile =~ /\\.eps\\Z/\n imgfile = File.basename(imgfile, \".eps\")\n img_refs[label.strip] = imgfile\n \"\\n//image[#{imgfile}][#{caps}]{\\n//}\\n\"\n elsif imgfile =~ /\\.pdf\\Z/\n imgfile = File.basename(imgfile, \".pdf\")\n img_refs[label.strip] = imgfile\n \"\\n//image[#{imgfile}][#{caps}]{\\n//}\\n\"\n else\n m\n end\n end\n\n str.gsub!(/^\\s*\\\\includegraphics(?:\\[.*?\\])?\\{(.+?)\\}[\\s\\n]*\\\\caption\\{(.+?)\\}/) do |m|\n imgfile = File.basename($1.strip)\n caps = $2.strip\n imgfile.gsub!(/\\.\\w+\\Z/, \"\")\n \"\\n//image[#{imgfile}][#{caps}]{\\n//}\\n\"\n end\n\n str.gsub!(/図\\s*\\\\ref\\{([^\\}]*)\\}/) do |m|\n \"@<img>#{LBRACE}#{img_refs[$1.strip] || $1.strip}#{RBRACE}\"\n end\n\n str.gsub!(/^\\s*\\\\begin\\{enumerate\\}((?:.|\\n)*)\\s*\\\\end\\{enumerate\\}/) do |m|\n block = $1\n idx = 0\n if block =~ /\\\\begin/\n block\n else\n items = block.strip.split(/\\\\item\\s*/).select{|s| s.size > 0}\n items_str = \"\\n\"\n items.each do |item|\n items_str += \" \" + (idx += 1).to_s + \". \" + item.gsub(/\\n\\s*/,\"\").strip + \"\\n\"\n end\n items_str\n end\n end\n\n str.gsub!(/^\\s*\\\\begin\\{itemize\\}((?:.|\\n)*)\\s*\\\\end\\{itemize\\}/) do |m|\n block = $1\n if block =~ /\\\\begin/\n block\n else\n items = block.strip.split(/\\\\item\\s*/).select{|s| s.size > 0}\n items_str = \"\\n\"\n items.each do |item|\n items_str += \" * \" + item.gsub(/\\n\\s*/,\"\").strip + \"\\n\"\n end\n items_str\n end\n end\n\n # brainfuck\n str.gsub!(/\\\\verb\\|([-+><,\\.\\[\\] ]+)\\|/) do |m|\n %!@<tt>#{LBRACE}#{$1}#{RBRACE}!\n end\n\n # file url in hoge.tex\n str.gsub!(/\\{\\\\scriptsize((?:.|\\n)+?)\\}/) do |m|\n s = $~[1].strip\n if s.strip =~ URI.regexp && s == $~[0]\n s\n else\n m\n end\n end\n\n str\nend",
"def knock71(word)\n\nend",
"def test_long_string\n assert_equal(\"g\", @target.find_first_non_repeating(\"learning javascript is pretty lame\"))\n end",
"def nicer_strings(input)\n strings = input.split(\"\\n\").map(&:strip)\n nice_count = 0\n strings.each do |string|\n match = match?(string)\n triplets = triplets?(string)\n nice_count += 1 if match && triplets\n end\n nice_count\nend",
"def bump(x)\n x.count(\"n\") <= 15 ? \"Woohoo!\" : \"Car Dead\"\nend",
"def wookiee_sentence; end",
"def nice(position)\n if position == :left_wield\n \"left hand\"\n elsif position == :right_wield\n \"right hand\"\n elsif position == :dual_wield\n \"both hands\"\n elsif position == :wield\n \"a hand\"\n else\n position.to_s.gsub(/_/, ' ')\n end\n end",
"def cartmans_phrase (string) #fix\n puts \"I'm not fat; I'm big-boned,\" + (string) #fix\nend",
"def throw_fierce_lqqks\n 'Here I am, giving you Soviet-Satellite realness'\n end",
"def pirates_say_arrrrrrrrr(string)\n text = \"\"\n r_exist = false\n string.split('').each do |chr|\n if r_exist == true\n text << chr\n r_exist = false\n elsif chr.downcase == \"r\"\n r_exist = true\n end\n end\n text\nend",
"def get_trite_disc_nickname\n adjectives=\n [ \"astounding\",\n \"batshit\",\n \"benign\",\n \"cracked\",\n \"creased\",\n \"crunched\",\n \"crippled\",\n \"crushed\",\n \"dismayed\",\n \"doomed\",\n \"flamenco-dancing\",\n \"folded\",\n \"harmless\",\n \"hazed\",\n \"inebriated\",\n \"inert\",\n \"malignant\",\n \"maligned\",\n \"marbled\",\n \"mutilated\",\n \"oblate\",\n \"obnoxious\",\n \"obsolete\",\n \"pathetic\",\n \"particular\",\n \"polycarbonate\",\n \"perky\",\n \"sad\",\n \"scored\",\n \"scratched\",\n \"screwy\",\n \"scuffed\",\n \"soul-crushing\",\n \"spindled\",\n \"spiralled\",\n \"splattered\",\n \"toothpaste-covered\",\n \"unbalanced\",\n \"verboten\",\n \"wafer-thin\"\n ]\n\n nouns =\n [ \"artifact\",\n \"chunk of your past\",\n \"disc\",\n \"donut\",\n \"frisbee\",\n \"hocky puck\",\n \"orblette\"]\n \n description = adjectives.sample\n\n while [true,false].sample do\n adj = adjectives.sample\n if !description.include? adj\n description+=\", \"+adj\n end\n end\n\n description+=\" \"+nouns.sample\nend",
"def digester(string, missed_cleavages) # Returns an array of chomped sequences\n\tstring.upcase!\n\tarr = (0..(string.upcase.length-1)).map {|i| string[i]}\n\tmisses = 0; splits = []\n\t(0..missed_cleavages).each do |miss_cleav|\n\t\t(0..missed_cleavages).each do |init_num|\n\t\t\tlast, curr, next_item = nil, nil, nil; keeper = \"\"\n\t\t\tmisses = init_num\n\t\t\tarr.each_index do |i|\n\t\t\t\tlast = arr[i-1]; curr = arr[i]; next_item = arr[i+1]\n\t\t#\tputs \"last, curr, next: #{last}, #{curr}, #{next_item}\"\n\t\t\t\tkeeper << curr if curr\n\t\t#\tputs \"keeper: #{keeper}\"\n\t\t\t\tif curr == 'R' or curr == 'K'\n\t\t\t\t\tunless next_item == \"P\"\n\t\t#\t\t\t\tputs \"misses:missed cleavages\t\t\t#{misses}:#{miss_cleav}\"\n\t\t\t\t\t\tif misses < miss_cleav\n\t\t\t\t\t\t\tmisses += 1\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tsplits << keeper\n\t\t\t\t\t\t\tkeeper = \"\";\tmisses = 0\n\t\t\t\t\t\tend\n\t\t\t\t\tend\n\t\t\t\tend\n\t\t\t\tsplits << keeper if next_item == nil\n\t\t#\t\tputs \"Splits looks like: #{splits}\"\n\t\t\tend\n\t\tend\t\t\t\n\tend\n\tsplits.uniq\nend",
"def cutinfo(string)\n inf=/\\024/=~string1\n inf=inf+2\n trans=string1[inf..-1]\nend",
"def two_strings(man, woman)\n p \"When \" + man + \" Met \" + woman\nend",
"def double_metaphone(str); end",
"def shout(word)\n# irb(main):012:1> \nreturn \"HOLA\"\n# irb(main):013:1> \nend",
"def solution(str)\n str.scan(/.{1,2}/).map { |e| e[1].nil? ? e + '_' : e }\nend",
"def friendly_parrot(name, age)\n \"Hi, Are you #{name}? You're #{age} years old.\"\nend",
"def snippet(text, wordcount, omission)\n return '' if text.blank?\n text.split[0..(wordcount-1)].join(\" \") + (text.split.size > wordcount ? \" \" + omission : \"\")\n end",
"def pirates_say_arrrrrrrrr(string)\n resultArr = []\n\n string.split(\"\").each_index do |x|\n if (string[x].downcase === \"r\" && string[x+1] != nil)\n resultArr.push(string[x+1])\n end\n end\n\n return resultArr.join(\"\")\n\n\nend",
"def outDescription\n begin\n if (self.howout_before_type_cast == 0 || self.howout_before_type_cast == 1 || self.howout_before_type_cast > 7) then\n #description is enough, as these ways of getting out do\n # not relate to any fielders.\n howout\n elsif (self.howout_before_type_cast == 2) then\n #bowled out\n \"b #{self.bowler.name}\"\n elsif (self.howout_before_type_cast == 3) then\n if (self.bowler.name != self.fielder.name) then\n #caught by a different fielder to the bowler\n \"c #{self.fielder.name} b #{self.bowler.name}\"\n else\n #caught and bowled both by the bowler\n \"c & b #{self.bowler.name}\"\n end\n elsif (self.howout_before_type_cast == 4) then\n \"lbw b #{self.bowler.name}\"\n elsif (self.howout_before_type_cast == 5) then\n \"run out (#{self.fielder.name})\"\n else\n \"stumped #{self.fielder}\"\n end\n rescue NoMethodError\n #Something went wrong - perhaps the user entered an invalid\n #combination, such as Caught, but left the bowler field blank\n \"ERROR - PLEASE EDIT THIS INNINGS AND CORRECT IT\"\n end\n end",
"def description\n description = puts \"Shelves containing food and other common supplies line the walls \"\\\n \"here. These things were probably stolen from the local village or nearby farms during \"\\\n \"raids. Although there doesn't seem to be anything of value here, you never know what a \"\\\n \"search will turn up.\"\n puts \"You can go back the way you came from.\"\n if @monster\n puts \"An evil #{@monster.monster} is here, ruffling for something to eat.\"\n else\n puts \"The squeek of a rat and pitter-patter of tiny rodent feet is all you hear.\"\n end\n end",
"def breakfast(cereal=\"frosted flakes\")\n \"Morning is the best time for #{cereal}!\"\nend",
"def pirates_say_arrrrrrrrr(string)\n\t#string_array = string.split(\"\")\n\t#string_array.each { |string| \"r\" +1}\n\t#puts string_array \n\n\tstring_array = string.split(\"\")\n\tnew_array = []\n\tstring_array.each_index do |x| \n\t\tunless x - 1 < 0\n\t\tif string_array.fetch(x - 1) == 'r'\n\t\t\tnew_array << string_array.fetch(x) \n\t\telsif string_array.fetch(x - 1) == 'R' \n\t\t\tnew_array << string_array.fetch(x) \n\t\tend\n\tend\n\tend\n\tnew_array.join\nend",
"def get_notes(string, fret)\n raise \"bad string\" if string < 1 or string > 6\n raise \"bad fret\" if fret < 0 or fret > 15\n base_offset = 0\n base_offset =\n case(string)\n when 1 then 7\n when 2 then 2\n when 3 then 10\n when 4 then 5\n when 5 then 0\n when 6 then 7\n end\n offset = base_offset + fret\n # puts offset\n note_index = offset % NOTE_NAMES.size\n # puts note_index\n NOTE_NAMES[note_index]\nend",
"def pirates_say_arrrrrrrrr(string)\n pirate = \"\"\n # Add a blank index at the end of string in case it ends in 'r'\n string << \" \"\n string.each_char.with_index { |chr, ind|\n pirate << string[ind+1] if [\"r\",\"R\"].include?(chr)\n }\n # strip to remove that extra space at the end\n pirate.strip\nend",
"def details\n \"This Oreo Cookie has #{filling_type} Filling Type and #{sugar}g of sugar and #{butter}g of butter\"\n end",
"def summary\n\t\tsummary = \"\"\n\t\tget = @text.split(/ /)\n\t\tget.each_index do |word|\n\t\t\tsummary << get[word] << \" \" if word < 10\n\t\tend\n\t\tsummary.strip\n\tend",
"def wookie_sentence; end",
"def stylish_chef\n best_hairstyle = \"Guy Fieri\"\n return \"Martha Stewart\"\n \"Guy Fieri\"\nend",
"def status_in_words\n return \"Champion's Bracket\" if status == 1\n return \"Second Chance Bracket\" if status == 2\n return \"Knocked Out for the season!\"\n end",
"def badish\n# Post process each bad entry to match against the profesor names in a regular expression fashion\nbad.each do |item|\n # unpack\n id = materias[item][0]\n rfc = materias[item][3]\n p_name = materias[item][4]\n #puts materias[item].inspect if (DEBUG)\n\n #name = []\n profesores.each do |profesor|\n # normalize string and split into words\n name = profesor[1].chomp.upcase.gsub(/\\s+/,' ').gsub(/(M\\.[ICAG]|L\\.A|I\\.Q|ING|FIS|MTRO|MRTO|DRA?)\\.?$/,\"\").split(\" \")\n # match the known name against a regular expression\n if (name.length >= 5)\n regex = Regexp.new(\"^\"+name[0]+\" \"+name[1]+\" \"+name[2]+\" \"+name[3]+\" \"+name[4])\n puts [p_name , name , regex].inspect if (p_name =~ regex)\n end\n if (name.length >= 4)\n regex = Regexp.new(\"^\"+name[0]+\" \"+name[1]+\" \"+name[2]+\" \"+name[3])\n puts [p_name , name , regex].inspect if (p_name =~ regex)\n end\n if (name.length >= 3)\n regex = Regexp.new(\"^\"+name[0]+\" \"+name[1]+\" \"+name[2])\n puts [p_name , name , regex].inspect if (p_name =~ regex)\n end\n if (name.length >= 2)\n regex = Regexp.new(\"^\"+name[0]+\" \"+name[1])\n puts [p_name , name , regex].inspect if (p_name =~ regex)\n end\n end\nend\nend",
"def hero_downfall (super_power, weakness)\n p \"They may have #{super_power}, but they're no match for #{weakness}!\"\nend",
"def speak_to_grandma(thing_said)\n return thing_said==thing_said.upcase ? \"NO, NOT SINCE 1938!\" : \"HUH?! SPEAK UP, SONNY!\"\nend",
"def friendly_parrot(name, age)\n age\n \"Hello! Your name is #{name} and you are #{age} years old.\"\nend",
"def spell(n)\n result = \"\"\n remaining = n\n \n while (remaining > 0) \n result.insert(0, lookup(remaining % 10).concat(\" \"))\n remaining = remaining / 10\n end\n \n return result\nend",
"def hide_all_sins(string)\n string_test = \"\"\n string_test = string.scan(/\\d{3}-\\d{3}-\\d{3}/).join(\", \").gsub(/\\d{3}-\\d{3}-/, \"XXX-XXX-\") # => \"\"\n if string_test.empty? == false\n string_test\n else\n string\n end\nend",
"def cartmans_phrase\n puts \"I'm not fat; I'm big-boned!\"\nend",
"def cartmans_phrase\n puts \"I'm not fat; I'm big-boned!\"\nend",
"def cartmans_phrase\n puts \"I'm not fat; I'm big-boned!\"\nend",
"def cartmans_phrase\n puts \"I'm not fat; I'm big-boned!\"\nend",
"def cartmans_phrase\n puts \"I'm not fat; I'm big-boned!\"\nend",
"def cartmans_phrase\n puts \"I'm not fat; I'm big-boned!\"\nend",
"def cartmans_phrase\n puts \"I'm not fat; I'm big-boned!\"\nend",
"def silly_talk(str)\n vows = \"aeiou\"\n\n new_talk = str.split(\" \").map do |wrd|\n if vows.include?(wrd[-1].downcase)\n wrd + wrd[-1]\n else\n silly = wrd.split(\"\").map do |char|\n if vows.include?(char)\n char + \"b\" + char\n else\n char\n end\n end\n silly.join(\"\")\n end\n end\n\n new_talk.join(\" \")\nend",
"def pirates_say_arrrrrrrrr(string)\n a = string.split(\"\")\n return_string = Array.new\n\n a.length.times { |x| return_string.push(a[x + 1]) if a[x] == \"r\" || a[x] == \"R\" }\n\n return_string.join(\"\")\nend",
"def friendly_parrot (name, age)\n \"You are called #{name} and you are #{age}\"\nend",
"def pirates_say_arrrrrrrrr(string)\n holder = String.new\n i = 0\n until i+1 == string.length\n holder << string[i+1] if string[i] == \"r\" || string[i] == \"R\"\n i +=1\n end\n holder\nend",
"def cartmans_phrase(words)\n puts \"I'm not fat; I'm big-boned!\"\nend",
"def pirates_say_arrrrrrrrr(string)\n return_string = \"\"\n\n string_length = string.length\n\n for x in 0...string_length\n if string[x] == \"r\" || string[x] == \"R\"\n return_string << string[x+1] unless (x+1) == string_length\n end\n end\n return_string\nend",
"def description\n case @wrong_guesses\n when 1\n puts \"The head has been drawn.\"\n when 2\n puts \"The head and body have been drawn.\"\n when 3\n puts \"The head, body, and one arm have been drawn.\"\n when 4\n puts \"The head, body, and arms have been drawn.\"\n when 5\n puts \"The head, body, arms, and one leg have been drawn.\"\n when 6\n puts \"The head, body, arms, and legs have been drawn.\"\n when 7\n puts \"The head, body, arms, legs, and one eye have been drawn.\"\n puts \"One more wrong move, and he's dead!\"\n when 8\n puts \"The head, body, arms, legs, and eyes have been drawn.\"\n puts \"The hangman's dead, and you've lost!\"\n end\n puts \"\\n\"\n end",
"def pirates_say_arrrrrrrrr(string)\n s = \"\"\n ((0 ... string.length).find_all { |i| string.downcase[i,1] == 'r' }).each do |c|\n if c < (string.length-1) then s += string[c+1] end\n end\n return s\nend",
"def long_appearance\n # How Med does it:\n # description\n # glance\n # eq\n # inventory\n \"{!{FG#{description}\\n\\n{FY{#{short_name} is in excellent condition.\"\n end",
"def indefinite_long_description\n return \"something\"\n end",
"def create_second_text_message(first_response)\n%(When I feel #{first_response}, I will also feel:\nCarefree\nPeaceful \nRelieved\nMellow\nRelaxed)\n end",
"def job\r\n\r\n a = \"闻》4月27日报道】题：中国军机展开前所未有的威吓飞行 据多名政府高官26日透露，就在中国8艘海监船23日侵入尖阁诸岛（即我钓鱼岛及其附属岛屿——本网注）周边日本领海的同时，中国的战斗机等军用飞机在尖阁诸岛周边飞行超过40架次。 军用飞机多数是战斗机，中国投入了新型苏-27和苏-30。这些战斗机趁航空自卫队战斗机飞行员疲惫的时候蜂拥而至。政府高官称这是“前所未有的威吓”。 政府方面认为中国军机的威吓飞行是为了配合海监船侵入领海。 中国军机从上空对海上保安厅的防范态势和海上自卫队护卫舰、P-3C巡逻机的部署进行侦察，估计向海监船进行了通报。 23日上午7时23分至8时25分左右，8艘海监船相继进入尖阁周边海域。其中一艘逼近鱼钓岛（即我钓鱼岛——本网注）西北约一公里处。当日下午7时半左右，8艘海监船离开了日本领海。 在海监船侵入领海之际，中国的战斗机等军用飞机也开始朝尖阁周边飞去。这些飞机交替着逼近尖阁周边上空，每次逼近时航空自卫队那霸基地的F-15等战斗机就紧急出动。飞来的中国军机总共在40架次以上。 \"\r\n # a = \"In the above outline, expression is a Ruby expression \r\n # The ruby code here marker is where the code to executed \r\n # the expression evaluates to false.\"\r\n # xx <span>the</span> xx bbbb the xxxx the bb\r\n # 0123456789012345678901234567890123456789\r\n # a = \"xx the xx bbbb the xxxx the bb\"\r\n kw = \"中国\"\r\n # kw = \"the\"\r\n r = /#{kw}/\r\n marker = 0\r\n t1 = \"<span style='color: blue;'>\"\r\n t2 = \"</span>\"\r\n counter = 0\r\n maxnum = 3\r\n \r\n logout(\"====================================\")\r\n logout(\"a=\" + a)\r\n logout(\"Span added=\" + add_span(a, kw, t1, t2))\r\n \r\n # puts \"a=\" + a\r\n # puts\r\n # \r\n # puts add_span(a, kw, t1, t2)\r\n # puts\r\n \r\n # # 1\r\n # puts \"<1>\"\r\n # \r\n # puts \"r =~ a\"\r\n # puts r =~ a\r\n # \r\n # # 2\r\n # puts \"<2>\"\r\n # puts a\r\n # while r =~ a[marker..(a.size - 1)] && counter < maxnum do\r\n # \r\n # puts \"[Start while]========================\"\r\n # \r\n # puts \"marker=\" + marker.to_s\r\n # \r\n # # point = (r =~ a)\r\n # point = (r =~ a[marker..(a.size - 1)])\r\n # puts \"point=\" + point.to_s\r\n # puts\r\n # \r\n # puts \"a=\" + a\r\n # puts\r\n # \r\n # puts \"a[marker..(a.size - 1)]=\" + a[marker..(a.size - 1)]\r\n # puts\r\n # \r\n # \r\n # \r\n # a.insert(marker + point, t1)\r\n # a.insert(marker + point + t1.size + r.source.size, t2)\r\n # # a.insert(point, t1)\r\n # # a.insert(point + t1.size + r.source.size, t2)\r\n # \r\n # puts \"a=\" + a\r\n # puts\r\n # \r\n # marker += point + t1.size + r.source.size + t2.size\r\n # # marker = point + t1.size + r.source.size + t2.size\r\n # # marker = point + t1.size + r.source.size\r\n # # marker = point\r\n # \r\n # counter += 1\r\n # \r\n # puts \"marker=\" + marker.to_s\r\n # puts \"point=\" + point.to_s\r\n # puts\r\n # \r\n # puts \"[End while========================]\"\r\n # \r\n # end\r\n # \r\n # puts a\r\n \r\n \r\nend",
"def make_sentence (height_inches, age)\n return \"I am #{height_inches} inches tall and #{age} years old\"\nend",
"def pirates_say_arrrrrrrrr(string)\n\tstring.split('').select.with_index { |item, i|\n\t\tstring.split('')[i-1].downcase == 'r' if i > 0\n\t}.join\nend",
"def pirates_say_arrrrrrrrr(string)\n arr = string.downcase.split(\"\")\n r_array = []\n arr.each_with_index do |elem, index|\n if elem == \"r\"\n r_array << index + 1\n end\n end\n final = []\n r_array.each {|x| final << arr[x]}\n return final.join(\"\")\nend",
"def step1(str)\n r1,r2 = r12(str)\n r1_text = str[r1..-1]\n r2_text = str[r2..-1]\n\n case r2_text\n when /(anzas?|ic[oa]s?|ismos?|[ai]bles?|istas?|os[oa]s?|[ai]mientos?)$/i\n str[%r{#$&$}]=''\n return true\n when /(ic)?(ador([ae]s?)?|aci[óÓ]n|aciones|antes?|ancias?)$/ui\n str[%r{#$&$}]=''\n return true\n when /log[íÍ]as?/ui\n str[%r{#$&$}]='log'\n return true\n when /(uci([óÓ]n|ones))$/ui\n str[%r{#$&$}]='u'\n return true\n when /(encias?)$/i\n str[%r{#$&$}]='ente'\n return true\n end\n\n if r2_text =~ /(ativ|iv|os|ic|ad)amente$/i or r1_text =~ /amente$/i\n str[%r{#$&$}]=''\n return true\n end\n\n case r2_text\n when /((ante|[ai]ble)?mente)$/i, /((abil|i[cv])?idad(es)?)$/i, /((at)?iv[ao]s?)$/i\n str[%r{#$&$}]=''\n return true\n end\n false\n end",
"def car_no_puts(make, model)\n make + ' ' + model\nend",
"def get_quote(person)\n case person\n when 'Yoda'\n 'Do. Or do not. There is no try.'\n when 'Confucius'\n 'I hear and I forget. I see and I remember. I do and I understand.'\n else\n 'Do not worry about your difficulties in Mathematics. I can assure you mine are still greater.'\n end\nend",
"def pirates_say_arrrrrrrrr(string)\n newstring = ''\n string.downcase!\n string.length.times do |index|\n newstring += string[index + 1] if char_is_r(string, index) && next_char_not_nil(string, index)\n end\n newstring\nend",
"def good_vs_evil(good, evil)\n g = good.split.map(&:to_i)\n gt = g[0] * 1 + g[1] * 2 + g[2] * 3 + g[3] * 3 + g[4] * 4 + g[5] * 10\n e = evil.split.map(&:to_i)\n et = e[0] * 1 + e[1] * 2 + e[2] * 2 + e[3] * 2 + e[4] * 3 + e[5] * 5 + e[6] * 10\n return 'Battle Result: No victor on this battle field' if gt == et\n return 'Battle Result: Good triumphs over Evil' if gt > et\n return 'Battle Result: Evil eradicates all trace of Good' if gt < et\nend",
"def pirates_say_arrrrrrrrr(string)\nresult = \"\"\n string.size.times { |i| result << string[i+1] if string[i] == \"r\" || string[i] == \"R\"}\nreturn result\nend"
] |
[
"0.6288638",
"0.6200622",
"0.60731244",
"0.60665154",
"0.60089314",
"0.59571177",
"0.59512025",
"0.59426916",
"0.5941199",
"0.592064",
"0.5899853",
"0.58943903",
"0.5884555",
"0.586874",
"0.58502626",
"0.58115613",
"0.5811494",
"0.5808975",
"0.57971054",
"0.5795099",
"0.57858807",
"0.57732874",
"0.57729435",
"0.5764352",
"0.5728868",
"0.57173765",
"0.5715083",
"0.5688033",
"0.56858754",
"0.5677059",
"0.56712073",
"0.56630534",
"0.5654766",
"0.5651555",
"0.5650896",
"0.56450474",
"0.5644999",
"0.5643319",
"0.5640681",
"0.5638848",
"0.5636962",
"0.5636513",
"0.5633001",
"0.56320894",
"0.5631734",
"0.5627047",
"0.5621097",
"0.5615881",
"0.5611066",
"0.5608534",
"0.56082416",
"0.56071925",
"0.5605262",
"0.5602425",
"0.5596851",
"0.5585405",
"0.5584483",
"0.5583843",
"0.5570535",
"0.5566595",
"0.5565543",
"0.55619836",
"0.556073",
"0.5543672",
"0.5539634",
"0.55381405",
"0.5537281",
"0.5527174",
"0.5526914",
"0.5523333",
"0.55222595",
"0.5521019",
"0.55197597",
"0.5514051",
"0.5514051",
"0.5514051",
"0.5514051",
"0.5514051",
"0.5514051",
"0.5514051",
"0.551081",
"0.5510148",
"0.5509964",
"0.55093855",
"0.55082554",
"0.55080026",
"0.55052435",
"0.5504011",
"0.55022913",
"0.55007344",
"0.549312",
"0.54894847",
"0.54865175",
"0.54859155",
"0.54831386",
"0.5482794",
"0.5482779",
"0.5475259",
"0.54745376",
"0.5474313",
"0.5473888"
] |
0.0
|
-1
|
makes a request and raises in case of Riot API error
|
def make_request(url)
res = Typhoeus::Request.new(
url,
method: :get,
headers: {
"Accept-Charset": "application/x-www-form-urlencoded; charset=UTF-8",
"Accept-Language" => "en-US,en;q=0.9,pt;q=0.8",
"X-Riot-Token" => @api_key.to_s,
"User-Agent": "https://github.com/drish/rioter"
}
).run
parse!(res)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def make_request(method, url, params = {})\n path = \"#{EbanqApi.base_url}/#{url}\"\n response = case method\n when :get then get(path, headers, params)\n when :post then post(path, headers, params)\n when :put then put(path, headers, params)\n when :delete then delete(path, headers)\n else raise 'Error'\n end\n process_raw_response(response)\n rescue RestClient::ResourceNotFound, SocketError, Errno::ECONNREFUSED => e\n raise e\n end",
"def api_error; end",
"def request(uri, req = nil, &block)\n response = super(uri, req, &block)\n\n # Evaluate HTTP response.\n case response\n when Net::HTTPSuccess\n return response\n when Net::HTTPUnauthorized\n raise Error.new('unauthorized', 'Missing, invalid or expired access token.')\n when Net::HTTPForbidden\n raise Error.new('forbidden', 'Insufficient permission.')\n when Net::HTTPNotFound\n return nil\n when Net::HTTPMethodNotAllowed\n raise Error.new('method_not_allowed', 'Unexpected request method.')\n when Net::HTTPServiceUnavailable\n raise Error.new('service_unavailable', 'Exceeded rate limit.')\n else\n parsed_response = JSON.parse(response.body)\n raise Error.new(parsed_response['error'], parsed_response['error']['description'])\n end\n end",
"def request\n yield\n rescue Unauthorized, InvalidRequest => e\n raise e\n rescue StandardError => e\n raise UnkownError.new(e)\n end",
"def raw_request(type, attributes)\n RestClient.send(type, *attributes)\n rescue RestClient::Forbidden\n raise Discordrb::Errors::NoPermission, \"The bot doesn't have the required permission to do this!\"\n rescue RestClient::BadGateway\n Discordrb::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')\n retry\n end",
"def raw_request(type, attributes)\n RestClient.send(type, *attributes)\n rescue RestClient::Forbidden\n raise Discordrb::Errors::NoPermission, \"The bot doesn't have the required permission to do this!\"\n rescue RestClient::BadGateway\n Discordrb::LOGGER.warn('Got a 502 while sending a request! Not a big deal, retrying the request')\n retry\n end",
"def request(uri, req = nil, &block)\n response = super(uri, req, &block)\n\n # Evaluate HTTP response.\n case response\n when Net::HTTPSuccess\n return response\n when Net::HTTPBadRequest\n hash = JSON.parse(response.body)\n description = hash[\"error_description\"]\n\n if hash[\"error\"]\n description ||= hash[\"error\"][\"description\"]\n code = hash[\"error\"][\"code\"]\n end\n\n raise Error.new(hash[\"error\"], description, code)\n when Net::HTTPUnauthorized\n raise Error.new(\"unauthorized\", \"Missing, invalid or expired access token.\")\n when Net::HTTPForbidden\n raise Error.new(\"forbidden\", \"Insufficient permission.\")\n when Net::HTTPNotFound\n return nil\n when Net::HTTPMethodNotAllowed\n raise Error.new(\"method_not_allowed\", \"Unexpected request method.\")\n when Net::HTTPServiceUnavailable\n raise Error.new(\"service_unavailable\", \"Exceeded rate limit.\")\n else\n raise Error.new(\"internal_server_error\", \"We are very sorry, but something went wrong.\")\n end\n end",
"def make_request\n query = {'income': @income, 'zipcode': @zipcode, 'age': @age}\n begin\n response = HTTParty.get(BASE_URL, query: query)\n # I know I can do better than this\n rescue Exception => e\n raise RequestException\n else\n response\n end\n end",
"def make_request(method, endpoint, payload={})\n params = [\"#{API_URL_BASE}/#{endpoint}\", payload, @request_header]\n begin\n JSON.parse RestClient.send(method.to_sym, *params.reject { |p| p.empty? })\n rescue RestClient::Unauthorized => e\n # an authorization error is indicative that the configuration won't work,\n # not that an individual request errored, so raise instead of recovering\n raise \n rescue RestClient::Exception => e\n # attempt to handle other RestClient exceptions gracefully\n # return the erorr message and keep moving\n return { \"error\" => e.message }\n end\n end",
"def request(method)\n setup_client\n respond_with @client.request(method, @request.url, nil, @request.body, @request.headers, &@request.on_body)\n rescue OpenSSL::SSL::SSLError\n raise SSLError\n rescue Errno::ECONNREFUSED # connection refused\n $!.extend ConnectionError\n raise\n end",
"def request!(&request)\n Transloadit::Response.new yield\n rescue RestClient::Exception => e\n Transloadit::Response.new e.response\n end",
"def requestIngestAPI(method, url, timeout, payload, additionalErrorMessage=\"\")\n begin\n response = RestClient::Request.new(\n :method => method,\n :url => $oc_server + url,\n :user => $oc_user,\n :password => $oc_password,\n :timeout => timeout,\n :payload => payload\n ).execute\n rescue RestClient::Exception => e\n BigBlueButton.logger.error(\" A problem occured for request: #{url}\")\n BigBlueButton.logger.info( e)\n BigBlueButton.logger.info( e.http_body)\n BigBlueButton.logger.info( additionalErrorMessage)\n exit 1\n end\n\n return response\nend",
"def make_request(request, error)\n # URI request with timeouts\n uri = URI.parse(\"https://derpiboo.ru/#{request}\")\n http = Net::HTTP.new(uri.host, uri.port)\n http.open_timeout = 10\n http.read_timeout = 20\n http.use_ssl = true\n attempts = 1\n # Limit attempts so we dont annoy Derpibooru too badly\n response = nil\n while (attempts < 4) && response.nil?\n begin\n response = http.request_get(uri.request_uri)\n rescue\n sleep(attempts * 2)\n attempts += 1\n end\n end\n\n if response\n return JSON.parse(response.body)\n else\n error = \"Could not get a response from Derpibooru. Wait a few minutes and try again.\"\n return nil\n end\n end",
"def perform_request url\n response = self.class.get(url)\n raise NotFound.new(\"404 Not Found\") if response.respond_to?(:code) && response.not_found?\n raise InvalidAPIResponse.new(response[\"status\"][\"message\"]) if response.is_a?(Hash) && response[\"status\"]\n\n response\n end",
"def request(method, path, params = {})\n req = create_request path\n req.request method.upcase, params do |response|\n if (200..300).cover?(response.status)\n yield response.json if block_given?\n else\n warn response.json['error']\n end\n end\n end",
"def do_request(uri, request, manage_errors = true, timeout = 10)\n begin \n http = build_http(uri, timeout)\n if(manage_errors)\n return error_manager(uri, http.request(request))\n else\n http.request(request)\n return { \"Success\" => true }\n end\n rescue Timeout::Error\n raise Ropenstack::TimeoutError, \"It took longer than #{timeout} to connect to #{uri.to_s}\"\t\n rescue Errno::ECONNREFUSED\n raise Ropenstack::TimeoutError, \"It took longer than #{timeout} to connect to #{uri.to_s}\"\t\n end\t\n end",
"def execute\n uri = request_uri\n http = Net::HTTP.new(uri.host, uri.port)\n request = Net::HTTP::Get.new(uri.request_uri)\n retries = Europeana.max_retries\n \n begin\n response = http.request(request)\n rescue Timeout::Error, Errno::ECONNREFUSED, EOFError\n retries -= 1\n raise unless retries > 0\n sleep Europeana.retry_delay\n retry\n end\n \n json = JSON.parse(response.body)\n raise Errors::RequestError, json['error'] unless json['success']\n json\n rescue JSON::ParserError\n raise Errors::ResponseError\n end",
"def request(method, parameters={})\n body = wrap_json(method, parameters)\n header = {'Content-Type' => \"text/json\"}\n \n # Clear retry cound here so it's fresh for each new request we make\n @retries = 0\n \n # Send the request\n send_request(body, header)\n\n end",
"def errback(http)\n raise \"Web API rtm.start failed: #{http.error}\"\n end",
"def request(method, uri, options={})\n options.deep_merge!(@auth_options)\n\n puts \"* requesting #{method.upcase} #{uri}\"\n response = self.class.send(method, uri, options)\n json = JSON.parse(response.body)\n\n while response.code.to_s !~ /^2/\n # if error other than 503, log and move on\n if response.code.to_s !~ /^503/\n puts \"* error: #{json['errorCode']}: #{json['message']}\"\n break \n end\n \n # if 503 (exceeded rate limit), wait and try again\n puts \"* waiting 60 seconds due to an error: #{json['errorCode']}: #{json['message']}\"\n sleep(60)\n puts \"* retrying #{method.upcase} #{uri}\"\n response = self.class.send(method, uri, options)\n json = JSON.parse(response.body)\n end\n\n return json, response.code\n end",
"def rest_request options\n defaults = {\n headers: { :content_type => :json },\n timeout: @timeout,\n open_timeout: @open_timeout,\n user: @username,\n password: @password,\n }\n\n expected_code = options.delete(:expected_code) || 200\n\n RestClient::Request.execute(defaults.merge(options)).tap do |response|\n unless response.code == expected_code\n raise LBModelException.new \"Expected HTTP #{expected_code} but got #{response.code} instead\"\n end\n end\n end",
"def rest_request options\n defaults = {\n headers: { :content_type => :json },\n timeout: @timeout,\n open_timeout: @open_timeout,\n user: @username,\n password: @password,\n }\n\n expected_code = options.delete(:expected_code) || 200\n\n RestClient::Request.execute(defaults.merge(options)).tap do |response|\n unless response.code == expected_code\n raise LBModelException.new \"Expected HTTP #{expected_code} but got #{response.code} instead\"\n end\n end\n end",
"def send_request(type,params)\n request_url = prepare_url(type,params)\n log \"Request URL: #{request_url}\"\n res = nil\n RemoteUtil.do_with_retry(exceptions: [TimeoutError, InternalServerError]) do |except|\n begin\n if not except.nil?\n puts \"Error calling BestBuy API, will retry: \" + except.to_s\n end\n res = Net::HTTP.get_response(URI::parse(request_url))\n rescue Timeout::Error\n raise BestBuyApi::TimeoutError, \"Timeout calling #{request_url}\"\n end\n if res.kind_of? Net::HTTPSuccess\n # Successful HTTP result.\n elsif res.kind_of? Net::HTTPInternalServerError\n raise BestBuyApi::InternalServerError, \"HTTP Response: #{res.code} #{res.message} for #{request_url}\"\n else\n raise BestBuyApi::RequestError, \"HTTP Response: #{res.code} #{res.message} for #{request_url}\"\n end\n end\n begin\n JSON.parse(res.body)\n rescue JSON::ParserError\n raise BestBuyApi::RequestError, \"Bad Response: JSON Parser Error for #{request_url}\"\n end\n \n end",
"def run\n\n action Colors.grey(\"REQUEST \") + Colors.light_blue(\"#{options[:method].upcase} #{url}\")\n Console.instance.indent\n # run the request\n options[:ssl_verifypeer] = false\n options[:followlocation] = true\n\n Injector.decorate(options)\n\n # convert all headers keys to strings to avoid having symbols like :\"header\" when\n # declaring headers with colons instead of arrows\n if options.key?(:headers)\n new_opts = {}\n options[:headers].map do |k, v|\n new_opts[k.to_s] = v\n end\n options[:headers] = new_opts\n end\n\n if options.key?(:headers) and options[:headers].key?('Content-Type')\n ctype = options[:headers]['Content-Type']\n if ctype.include?('application/json')\n # automatically encode json content\n options[:body] = JSON.generate(options[:body], quirks_mode: true)\n end\n end\n\n\n\n self.response = Typhoeus::Request.new(url, options).run\n\n self.req_response = RequestResponse.new.tap { |r|\n r.raw_body = response.body\n r.headers = response.headers\n r.code = response.code\n r.total_time = response.total_time\n\n if !r.headers.nil? && r.headers.key?('Content-Type') && r.headers['Content-Type'].include?('application/json')\n r.body = JSON.parse(response.body)\n else\n r.body = response.body\n end\n }\n\n # reset assertion counter\n self.assert_no = 1\n\n # evaluate response against expectations\n begin\n instance_eval(&expectations)\n rescue AssertionException\n error error_msg + \" at #{expectations.source_location}\"\n raise RequestException\n rescue StandardError => e\n error 'Exception ' + e.message\n info e.backtrace.inspect\n _debug_info\n error error_msg\n raise RequestException\n ensure\n Console.instance.unindent\n end\n\n req_response\n\n end",
"def request(params)\n\n # Add auth header\n headers = params[:headers] || {}\n headers['x-vcloud-authorization'] = @auth_key if !@auth_key.nil? || !@auth_key.equal?('')\n\n # set connection options\n options = {:url => params[:url],\n :body => params[:body] || '',\n :expects => params[:expects] || 200,\n :headers => headers || {},\n :method => params[:method] || 'GET'\n }\n\n # connect\n res = RestClient::Request.execute options\n\n raise res if (res.code!=params[:expects] && res.code!=200)\n\n res\n\n\n end",
"def http(method, *args)\n args.last.merge!(self.default_headers).merge!(\"X-Auth-Token\" => self.auth_token)\n response = RestClient.send(method, *args)\n @retried = false\n response\n rescue RestClient::Unauthorized\n @auth_response = nil\n if @retried\n raise\n else\n @retried = true\n retry\n end\n end",
"def send_request(method, options = {})\n http_method = :get\n endpoint = REST_API_ENDPOINT\n options.merge!(:api_key => @api_key, :method => method)\n sign_request(options)\n \n rsp = http_request(options, http_method, endpoint)\n \n rsp = '<rsp stat=\"ok\"></rsp>' if rsp == \"\"\n xm = XmlMagic.new(rsp)\n \n if xm[:stat] == 'ok'\n xm\n else\n raise Rocinante::Errors.error_for(xm.err[:code].to_i, xm.err[:msg])\n end\n end",
"def send_request_of_type(request_type, path)\n begin\n\n request_path = GlobalConstant::ExplorerApi.base_url + path\n\n # It overrides verification of SSL certificates\n ssl_context = OpenSSL::SSL::SSLContext.new\n ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE\n\n parameterized_token = {token: get_jwt_token({url: \"/#{path}\",\n request_time: Time.now.to_i})}\n\n case request_type\n when 'get'\n response = HTTP.timeout(@timeouts)\n .get(request_path, params: parameterized_token, ssl_context: ssl_context)\n when 'post'\n response = HTTP.timeout(@timeouts)\n .post(request_path, json: parameterized_token, ssl_context: ssl_context)\n else\n return error_with_data(\n 'l_ea_b_1',\n 'something_went_wrong',\n GlobalConstant::ErrorAction.default,\n {request_type: request_type}\n )\n end\n\n case response.status\n when 200\n parsed_response = Oj.load(response.body.to_s)\n if parsed_response['success']\n return success_with_data(HashWithIndifferentAccess.new(parsed_response['data']))\n else\n # web3_js_error = true is required because when API is down or any exception is raised or response is not 200\n # front end doesn't need to see invalid ethereum address\n return error_with_data(\n parsed_response['err']['code']+':st(l_ea_b_2)',\n 'something_went_wrong',\n GlobalConstant::ErrorAction.default,\n {web3_js_error: true, status: response.status, msg: parsed_response['err']['msg']}\n )\n end\n else\n return error_with_data(\n 'l_ea_b_3',\n 'something_went_wrong',\n GlobalConstant::ErrorAction.default\n )\n end\n rescue => e\n return error_with_data(\n 'l_ea_b_4',\n 'something_went_wrong',\n GlobalConstant::ErrorAction.default,\n {message: e.message}\n )\n end\n end",
"def request(key, type, *attributes)\n # Add a custom user agent\n attributes.last[:user_agent] = user_agent if attributes.last.is_a? Hash\n\n begin\n if key\n @mutexes[key] = Mutex.new unless @mutexes[key]\n\n # Lock and unlock, i. e. wait for the mutex to unlock and don't do anything with it afterwards\n @mutexes[key].lock\n @mutexes[key].unlock\n end\n\n response = raw_request(type, attributes)\n rescue RestClient::TooManyRequests => e\n raise \"Got an HTTP 429 for an untracked API call! Please report this bug together with the following information: #{type} #{attributes}\" unless key\n\n unless @mutexes[key].locked?\n response = JSON.parse(e.response)\n wait_seconds = response['retry_after'].to_i / 1000.0\n Discordrb::LOGGER.warn(\"Locking RL mutex (key: #{key}) for #{wait_seconds} seconds due to Discord rate limiting\")\n\n # Wait the required time synchronized by the mutex (so other incoming requests have to wait) but only do it if\n # the mutex isn't locked already so it will only ever wait once\n @mutexes[key].synchronize { sleep wait_seconds }\n end\n\n retry\n end\n\n response\n end",
"def request(key, type, *attributes)\n # Add a custom user agent\n attributes.last[:user_agent] = user_agent if attributes.last.is_a? Hash\n\n begin\n if key\n @mutexes[key] = Mutex.new unless @mutexes[key]\n\n # Lock and unlock, i. e. wait for the mutex to unlock and don't do anything with it afterwards\n @mutexes[key].lock\n @mutexes[key].unlock\n end\n\n response = raw_request(type, attributes)\n rescue RestClient::TooManyRequests => e\n raise \"Got an HTTP 429 for an untracked API call! Please report this bug together with the following information: #{type} #{attributes}\" unless key\n\n unless @mutexes[key].locked?\n response = JSON.parse(e.response)\n wait_seconds = response['retry_after'].to_i / 1000.0\n Discordrb::LOGGER.warn(\"Locking RL mutex (key: #{key}) for #{wait_seconds} seconds due to Discord rate limiting\")\n\n # Wait the required time synchronized by the mutex (so other incoming requests have to wait) but only do it if\n # the mutex isn't locked already so it will only ever wait once\n @mutexes[key].synchronize { sleep wait_seconds }\n end\n\n retry\n end\n\n response\n end",
"def request(action, params={})\n retried = true\n\n begin\n response = HTTParty.send(*request_arguments(action, params))\n validate response\n\n rescue RequestError => e\n if e.invalid_token? and @token.respond_to?(:expired!) and not retried\n @token.expired!\n retried = true\n retry\n end\n\n return if e.not_found?\n raise \n end\n end",
"def test_WAPI_do_request_rest_client_error_417\n\n\n stub_request(:get, \"https://start/hey\").\n with(:headers => {'Accept' => 'application/json', 'Accept-Encoding' => 'gzip, deflate', 'Authorization' => 'Bearer sweet!'}).\n to_return(:status => 417, :body => \"\", :headers => {})\n\n a = Hash['api_prefix' => \"https://start\",\n 'key' => 'key',\n 'secret' => 'secret',\n 'token_server' => 'nowhere.edu',\n 'token' => 'sweet!'\n ]\n h = WAPI.new(a);\n\n r = h.do_request(\"/hey\")\n\n assert_equal(r.meta_status, 666, \"didn't get wrapped exception\")\n\n end",
"def api_request(params)\n authenticate\n response = cap_client.get \"#{API_PATH}#{params}\"\n JSON.parse(response.body)\n rescue Faraday::TimeoutError => e\n NotificationManager.error(e, 'Timeout error during CAP-API request', self)\n raise\n rescue StandardError => e\n NotificationManager.error(e, \"#{e.class.name} during CAP-API request\", self)\n raise\n end",
"def handle_http_error(res)\n if res.code == \"202\" # retry\n self.call\n else\n raise \"Error in FoodTruckApiClient: Call to API failed, returning the HTTP status code #{res.code} and the following error message: #{error}\"\n end\n end",
"def make_error(type, response, url: 'http://example.com', request_body: '{\"msg\": \"The request body\"}')\n error = nil\n\n begin\n begin\n raise Faraday::ClientError, \"The original error\"\n rescue Faraday::ClientError => e\n request = RestfulResource::Request.new(:get, url, body: request_body)\n raise type.new(request, response)\n end\n rescue Exception => e\n error = e\n end\n\n error\n end",
"def perform_api_request(query) \n request = Net::HTTP::Post.new( \n $url.path + ($url.query != nil ? (\"?\" + $url.query) : \"\"), \n initheader = {\"Content-Type\" => \"application/json\", \n \"X-Replicon-Security-Context\" => \"User\"}) \n request.basic_auth($companyKey + \"\\\\\" + $loginname, $password) \n request.body = JSON.generate(query) \n \n server = Net::HTTP.new($url.host, $url.port) \n server.use_ssl = $url.scheme == \"https\" \n response = server.start {|http| http.request(request)} \n \n http_code = response.code.to_i \n if http_code != 200 \n puts response.body \n raise \"Expected success code 200, but was #{http_code}\" \n end \n \n return JSON.parse(response.body) \nend",
"def request method, *params, **options\n json = {method: method, params: params, id: 1, version: '1.0'}.merge!(options).to_json\n ret = JSON.parse(@http.request_post(@uri.path, json).body)\n if ret['error']\n error_code, error_message = ret['error']\n raise Sonycam::Error.make(error_code), error_message\n else\n ret['result']\n end\n end",
"def request(method, url, headers = nil, payload = nil)\n headers ||= create_headers\n response = {response: nil, error: nil}\n begin\n resp = RestClient::Request.new(method: method,\n url: url,\n headers: headers,\n payload: payload).execute\n\n\n if resp.code == 404\n raise RestClient::ExceptionWithResponse\n elsif (resp.code >= 200) && (resp.code < 204)\n response[:response] = JSON.parse(resp.body.to_s)\n elsif resp.code == 204\n response[:response] = {'success': true}\n end\n\n rescue RestClient::ExceptionWithResponse => err\n err.http_code == 404 ? response[:error] = {'message': err.response.to_s} : JSON.parse(err.response)\n end\n response\n end",
"def request(*)\n raise 'HttpApiBuilder::BaseClient#request must be implemented, see documentation'\n end",
"def send_request(method, options = {}, http_method = :get, endpoint = REST_ENDPOINT)\n options.merge!(:api_key => @api_key, :method => method)\n sign_request(options)\n \n rsp = request_over_http(options, http_method, endpoint)\n \n rsp = '<rsp stat=\"ok\"></rsp>' if rsp == \"\"\n xm = XmlMagic.new(rsp)\n \n if xm[:stat] == 'ok'\n xm\n else\n raise Flickr::Errors.error_for(xm.err[:code].to_i, xm.err[:msg])\n end\n end",
"def _http_request(method, url, *args)\n request_args = get_hash_args(*args)\n url = get_url url unless url.to_s.start_with?('http://')\n request_args[:header] = @head\n request_args[:body] = \\\n JSON.dump(request_args[:body]) if request_args[:body]\n\n res = @http_session.request(method, url, request_args)\n status = res.status\n raise HTTPError, 'HTTPError: %s %s'\\\n % [status, (JSON.load(res.content)['message'] rescue res.reason)]\\\n if status >= 400 && status < 600\n res\n end",
"def call_api(req, rtype, data=nil)\n msg(\"#{rtype} REQ: #{req}\")\n res_hash = {:status => true, :response => \"\"}\n begin\n if rtype == 'POST'\n get_response = @client.send_post(req, data)\n else\n get_response = @client.send_get(req)\n end\n rescue Exception => e\n puts \"Raised Exception: #{e.message}.\"\n res_hash[:status] = false\n res_hash[:response] = e.message\n else\n res_hash[:status] = true\n res_hash[:response] = get_response\n end\n msg(\"RESPONSE: #{res_hash}\")\n return res_hash\n end",
"def request(method, path, options, headers)\n headers.merge!({\n 'User-Agent' => user_agent\n })\n\n options.merge!({\n :api_key => api_key\n })\n\n response = connection.send(method) do |request|\n request.url \"#{endpoint}#{path}\", options\n request.body = options\n request.headers = headers\n end\n Shirtsio::Utils.handle_api_error(response) if response.status != 200\n\n Shirtsio::Utils.parse_json(response.body)[:result]\n end",
"def make_request\n url = 'https://www.googleapis.com/qpxExpress/v1/trips/search?key=' + @api_key\n request = compose_request\n response = RestClient.post url, request, content_type: :json, accept: :json\n response.body\n end",
"def make_request\n response = @http.request(@request)\n end",
"def rest_send( url, method, payload )\n begin\n response = RestClient::Request.execute( method: method,\n url: URI.escape( url ),\n payload: payload,\n content_type: :json,\n accept: :json,\n timeout: self.timeout )\n\n if ok?( response.code ) && response.empty? == false && response != ' '\n return response.code, JSON.parse( response )\n end\n return response.code, {}\n rescue RestClient::BadRequest => ex\n log_error( method, url, nil, payload )\n return 400, {}\n rescue RestClient::ResourceNotFound => ex\n log_error( method, url, nil, payload )\n return 404, {}\n rescue RestClient::RequestTimeout => ex\n log_error( method, url, nil, payload )\n puts \"ERROR: request timeout: #{url}\"\n return 408, {}\n rescue RestClient::Exception, SocketError, Exception => ex\n log_error( method, url, ex, payload )\n return 500, {}\n end\n end",
"def throw_error(error)\n render json: error, status: :bad_request\n end",
"def make_request url, parameters={}, method=:get, settings={}\n raise 'not implemented'\n end",
"def send_api_request(method, params={}, data=nil)\n url = get_url(method, params)\n\n @http_response = send_request(url, data)\n return { } if @http_response.body.empty?\n\n # 'Hashify' the XML\n @xml_response = @http_response.body\n hash = Hash.from_xml(@xml_response)\n\n # simple validation of the xml body\n unless hash.has_key?(:returncode)\n raise BigBlueButtonException.new(\"Invalid response body. Is the API URL correct? \\\"#{@url}\\\", version #{@version}\")\n end\n\n # default cleanup in the response\n hash = BigBlueButtonFormatter.new(hash).default_formatting\n\n # if the return code is an error generates an exception\n unless hash[:returncode]\n exception = BigBlueButtonException.new(hash[:message])\n exception.key = hash.has_key?(:messageKey) ? hash[:messageKey] : \"\"\n raise exception\n end\n\n hash\n end",
"def make_request(request)\n result = self.class.post('/', body: request.to_json)\n\n if result.code >= 500\n raise Webceo::Api::ServerError.new(result.code, result.body)\n end\n\n if result.code >= 400\n raise Webceo::Api::ClientError.new(result.code, result.body)\n end\n\n Webceo::Api::Response.new(result.code, result.body, result.headers, result.message)\n end",
"def send_request(params, payload=nil, content_type=nil)\n headers = {:accept => \"application/*+xml;version=#{@api_version}\"}\n if @auth_key\n headers.merge!({:x_vcloud_authorization => @auth_key})\n end\n\n if content_type\n headers.merge!({:content_type => content_type})\n end\n\n request = RestClient::Request.new(:method => params['method'],\n :user => \"#{@username}@#{@org_name}\",\n :password => @password,\n :headers => headers,\n :url => \"#{@api_url}#{params['command']}\",\n :payload => payload)\n\n begin\n response = request.execute\n if ![200, 201, 202, 204].include?(response.code)\n @logger.warn \"Warning: unattended code #{response.code}\"\n end\n\n @logger.debug \"Send request result: #{Nokogiri.parse(response)}\"\n\n [Nokogiri.parse(response), response.headers]\n rescue RestClient::Unauthorized => e\n raise UnauthorizedAccess, \"Client not authorized. Please check your credentials.\"\n rescue RestClient::BadRequest => e\n body = Nokogiri.parse(e.http_body)\n message = body.css(\"Error\").first[\"message\"]\n humanize_badrequest(message)\n rescue RestClient::Forbidden => e\n body = Nokogiri.parse(e.http_body)\n message = body.css(\"Error\").first[\"message\"]\n raise UnauthorizedAccess, \"Operation not permitted: #{message}.\"\n rescue RestClient::InternalServerError => e\n body = Nokogiri.parse(e.http_body)\n message = body.css(\"Error\").first[\"message\"]\n raise InternalServerError, \"Internal Server Error: #{message}.\"\n rescue RestClient::MethodNotAllowed => e\n body = Nokogiri.parse(e.http_body)\n message = body.css(\"Error\").first[\"message\"]\n raise MethodNotAllowed, \"#{params['method']} to #{params['command']} not allowed: #{message}.\"\n end\n end",
"def rest_request(verb, url, data)\n if Rails.env.production?\n rest_production(verb, url, JSON.generate(data))\n else\n log_info(\"[#{Rails.env}]: #{verb} #{url}\", 200)\n end\n rescue RestClient::Exception => e\n log_error \"Failed with #{e.http_code}: #{e}\\n#{e.response}\", e.http_code\n end",
"def request(action, params = {})\n # Merge the default params with any custom ones\n params = @defaults.merge(params) unless !@defaults\n \n # Exception checks\n if !params[:apikey] || (params[:apikey].is_a?(Array) && params[:apikey].size < 1)\n raise MissingAPIKey\n end\n \n if params[:priority] && !PRIORITY_RANGE.include?(params[:priority])\n raise PriorityOutOfRange\n end\n \n # Raise an exception if we're trying to use more API keys than allowed for this action\n if params[:apikey].is_a?(Array) && ((action == 'verify' && params[:apikey].size > 1) || params[:apikey].size > MAX_API_KEYS)\n raise TooManyAPIKeys\n end\n \n # If there are multiple API Keys in an array, merge them into a comma-delimited string\n if params[:apikey].is_a?(Array)\n params[:apikey] = params[:apikey].collect{|v| v + ',' }.to_s.chop\n end\n \n # Delete any empty key/value sets\n params.delete_if {|key, value| value.nil? }\n \n # Make the request\n req = Typhoeus::Request.new(API_URL + action,\n :user_agent => @user_agent,\n :method => (action == 'add') ? :post : :get,\n :params => (action == 'add') ? params : {:apikey => params[:apikey]}\n )\n \n # Typhoeus request on_complete method adds the HTTP code to an array\n req.on_complete do |response|\n @responses << response.code\n end\n \n # Return the request\n req\n end",
"def request(http_method: :get, path:'/', body: nil, query: {}, headers: {}, response_block: nil, expects: [200, 201, 204], host: nil, port: nil, auth: true, gzip: true)\n\n retried ||= false\n\n if auth && token_expired?\n raise Excon::Error::Unauthorized, \"Token expired or not valid, you need to login again, use: kontena #{token_is_for_master? ? \"master\" : \"cloud\"} login\"\n end\n\n request_headers = request_headers(headers, auth: auth, gzip: gzip)\n\n if body.nil?\n body_content = ''\n request_headers.delete(CONTENT_TYPE)\n else\n body_content = encode_body(body, request_headers[CONTENT_TYPE])\n request_headers.merge!('Content-Length' => body_content.bytesize)\n end\n\n uri = URI.parse(path)\n host_options = {}\n\n if uri.host\n host_options[:host] = uri.host\n host_options[:port] = uri.port\n host_options[:scheme] = uri.scheme\n path = uri.request_uri\n else\n host_options[:host] = host if host\n host_options[:port] = port if port\n end\n\n request_options = {\n method: http_method,\n expects: Array(expects),\n path: path_with_prefix(path),\n headers: request_headers,\n body: body_content,\n query: query\n }.merge(host_options)\n\n request_options.merge!(response_block: response_block) if response_block\n\n # Store the response into client.last_response\n @last_response = http_client.request(request_options)\n\n parse_response(@last_response)\n rescue Excon::Error::Unauthorized\n if token\n debug { 'Server reports access token expired' }\n\n if retried || !token || !token['refresh_token']\n raise Kontena::Errors::StandardError.new(401, 'The access token has expired and needs to be refreshed')\n end\n\n retried = true\n retry if refresh_token\n end\n raise Kontena::Errors::StandardError.new(401, 'Unauthorized')\n rescue Excon::Error::HTTPStatus => error\n if error.response.headers['Content-Encoding'] == 'gzip'\n error.response.body = Zlib::GzipReader.new(StringIO.new(error.response.body)).read\n end\n\n debug { \"Request #{error.request[:method].upcase} #{error.request[:path]}: #{error.response.status} #{error.response.reason_phrase}: #{error.response.body}\" }\n\n handle_error_response(error.response)\n end",
"def request(method, path)\n uri = 'http://api.twitter.com/'+path\n connection.url_prefix = options[:endpoint] || @endpoint\n connection.run_request(:get, path, nil, nil)\n rescue Faraday::Error::ClientError\n raise Sociable::Error::ClientError\n end",
"def send_request method, params = {}\n uri = URI.parse(@api_url)\n if Time.now.to_i > @exp + 3600\n get_acces_token\n @exp = Time.now.to_i\n end\n required = { 'access_token' => @access_token, 'method' => method }\n params = required.merge(params)\n params = URI.escape(params.collect{ |k,v| \"#{k}=#{v}\"}.join('&'))\n http = Net::HTTP.new(uri.host, uri.port)\n req = Net::HTTP::Post.new(uri.request_uri)\n req['User-Agent'] = \"zhzhussupovkz pleer.com-ruby-api\"\n req.body = params\n res = http.request(req)\n if res.code == \"200\"\n data = res.body\n result = JSON.parse(data)\n else\n puts \"Invalid getting data from server\"\n exit\n end\n end",
"def send_request method, params = nil\n if params.nil?\n raise ArgumentError, \"Invalid request params\"\n else\n required = { 'api_key' => @api_key }\n params = required.merge(params)\n params = URI.escape(params.collect{ |k,v| \"#{k}=#{v}\"}.join('&'))\n end\n url = @api_url + method + '/?' + params\n raise ArgumentError, \"Can't send request to the server\" if not url.is_a? String\n uri = URI.parse(url)\n http = Net::HTTP.new(uri.host, uri.port)\n http.use_ssl = true\n http.verify_mode = OpenSSL::SSL::VERIFY_NONE\n req = Net::HTTP::Get.new(uri.request_uri)\n res = http.request(req)\n data = res.body\n if not data.is_a? String or not data.is_json?\n raise RuntimeError, \"Server returned incorrect format data.\"\n end\n result = JSON.parse(data)\n end",
"def request(method, path, options)\n if credentials?\n connection.params.merge! api_key: credentials[:api_key]\n end\n\n connection.url_prefix = endpoint\n response = connection.send(method) do |request|\n case method.to_sym\n when :get, :delete\n request.url path, options\n when :post, :put\n request.path = path\n request.body = options\n end\n end\n\n response.body\n # It seems like Faraday should have a way to handle this. Oh, well.\n rescue Faraday::ParsingError\n raise Error.new(\"Server Error\", \"Unable to parse JSON response\")\n end",
"def request_and_handle http_method, path, options\n if http_method.is_a?(String) || http_method.is_a?(Symbol)\n http_method = HTTP_METHODS[http_method.to_s]\n raise \"Unknown http method: #{http_method}\" unless http_method\n end\n \n req_options = default_options.dup\n req_options = req_options.merge(options)\n \n raise ConfigurationError.new \"No endpoint defined\" if !path || path.empty?\n raise ConfigurationError.new \"No hostname defined\" if !req_options[:base_uri] || req_options[:base_uri].empty?\n \n # prepare request\n req = HTTParty::Request.new http_method, path, req_options\n req.options[:timeout] = CityGrid.custom_timeout if req.options && CityGrid.custom_timeout_set?\n\n # Sanitized request for logs\n safe_req_options = strip_unsafe_params(http_method, req_options)\n req_to_output = HTTParty::Request.new http_method, path, safe_req_options\n req_for_airbrake = { :method => http_method, :path => path, :options => safe_req_options }\n\n begin\n response = req.perform\n rescue => ex \n if defined?(Rails.logger)\n Rails.logger.error safe_req_options\n Rails.logger.error req_to_output\n Rails.logger.error req_for_airbrake\n Rails.logger.error ex\n end\n raise CityGridExceptions::RequestError.new req_for_airbrake, nil, ex.message, req_to_output.to_curl\n ensure\n if CityGrid.print_curls? \n if defined?(Rails.logger)\n Rails.logger.info req_to_output.to_curl\n puts req_to_output.to_curl\n else\n puts req_to_output.to_curl\n end\n end\n end\n\n response_status = parse_response_status response\n \n begin \n # catch unparsable responses (html etc)\n if !response.parsed_response.is_a?(Hash)\n #pp \"[gem] the response was unparsable (response was not a hash)\"\n raise CityGridExceptions::ResponseParseError.new req_for_airbrake, response, \"the response was unparsable (response was not a hash)\", req_to_output.to_curl\n else\n # Parse and handle new response codes \n if !response_status.nil? && response_status[\"code\"] != \"SUCCESS\" && response_status[\"code\"] != 200\n raise CityGridExceptions.appropriate_error(response_status[\"code\"]).new req_for_airbrake, response, response_status[\"message\"].to_s, req_to_output.to_curl\n else\n return CityGrid::API::Response.new response\n end\n end\n rescue => ex\n pp \"API ERROR: #{ex}\"\n raise ex if CityGrid.raise_errors?\n end\n end",
"def request(params = {})\n params.merge!(default_params)\n http_proxy(proxyaddr, proxyport, proxyuser, proxypass)\n response = get(base_uri, :query => params)\n case response.code\n when 200\n if response[\"interface_response\"][\"ErrCount\"] == \"0\"\n return response\n else\n raise InterfaceError, response[\"interface_response\"][\"errors\"].values.join(\", \")\n end\n end\n end",
"def send_request\n setup_connection\n send_request_with_lazy_pirate unless error?\n end",
"def perform\n args = {\n :method => method,\n :url => url,\n :headers => headers,\n :timeout => 120,\n :open_timeout => 30\n }\n args[:payload] = payload.to_json if payload\n\n Response.new RestClient::Request.execute(args)\n rescue RestClient::Exception => e\n response = e.response\n\n if e.is_a?(RestClient::RequestTimeout)\n response = JSON.generate({:error => {:cause => 'REQUEST_TIMEDOUT'}})\n end\n\n ErrorResponse.new response\n end",
"def make_request(method, endpoint, payload={})\n params = [\"#{API_URL_BASE}/#{endpoint}\", payload, @request_header]\n begin\n JSON.parse RestClient.send(method.to_sym, *params.reject { |p| p.empty? })\n rescue RestClient::Exception => e\n return { \"error\" => e.message }\n end\n end",
"def api_request(method, uri, token, payload, options={})\n params = options.fetch('params', {})\n headers = options.fetch('headers', {})\n req_headers = headers.merge({params: params}).merge({'X-Auth-Token': token})\n RestClient::Request.execute(method: method.to_sym,\n url: uri,\n headers: req_headers,\n timeout: @timeout,\n payload: payload)\n end",
"def make_rest_call(method, url, payload = nil, headers = nil)\n options = call_options_builder(method, url, payload, headers)\n RestClient::Request.execute(options)\n rescue => e\n raise e\n end",
"def request(type, *attributes)\n raw = RestClient.send(type, *attributes, :'User-Agent' => \"WhatsThisClient (https://github.com/whats-this/owo.rb, v#{OwO::VERSION})\")\n json = parse_json(raw)\n return json\n rescue RestClient::RequestEntityTooLarge\n raise OwO::Err::TooLarge, 'Requested files are too large!'\n rescue RestClient::Unauthorized\n raise OwO::Err::BadToken, 'Token is invalid!'\n rescue RestClient::BadRequest => e\n raw = e.response\n json = parse_json(raw)\n raise OwO::Err::TooManyFiles, 'You requested too many files!' if json.is_a?(Hash) && json['description'] == 'too many files'\n raise OwO::Err::BadURL, 'Your URL is invalid!' if !json.is_a?(Hash) && raw == 'invalid URL'\n err = if json.is_a?(Hash)\n json['description']\n else\n raw\n end\n raise err\n rescue RestClient::InternalServerError\n raise OwO::Err::ServerFail, 'Server Error!'\n rescue RuntimeError => e\n raise e\n end",
"def init_request(url)\n request = Typhoeus::Request.new(\n url,\n method: :get,\n headers: {'User-Agent' => user_agent}, \n followlocation: true\n # proxy: ...,\n # proxyuserpwd: ...\n )\n\n request.on_complete do |response|\n if response.success?\n # do nothing here\n elsif response.timed_out?\n raise Hubberlyzer::ResponseError, \"Time out when requesting: #{url}\"\n elsif response.code != 200\n raise Hubberlyzer::ResponseError, \"Response code #{response.code}, #{response.return_message} when requesting: #{url}\"\n else\n # Received a non-successful http response.\n raise Hubberlyzer::ResponseError, \"HTTP request failed. Response code #{response.code} when requesting: #{url}\"\n end\n end\n\n request\n end",
"def default_error req, endpoint, error\n msg = \"= #{error.class}:\\n<b>#{error.message}</b>\\n\\n\"\n msg << error.backtrace\n\n response HTTP_INTERNAL_ERROR, api_html(msg)\n end",
"def request_and_handle http_method, path, options\n if http_method.is_a?(String) || http_method.is_a?(Symbol)\n http_method = HTTP_METHODS[http_method.to_s]\n raise \"Unknown http method: #{http_method}\" unless http_method\n end\n \n req_options = default_options.dup\n req_options = req_options.merge(options)\n \n raise ConfigurationError.new \"No endpoint defined\" if !path || path.empty?\n raise ConfigurationError.new \"No hostname defined\" if !req_options[:base_uri] || req_options[:base_uri].empty?\n \n # prepare request\n req = HTTParty::Request.new http_method, path, req_options\n\n # Sanitized request for logs\n safe_req_options = strip_unsafe_params(http_method, req_options)\n req_to_output = HTTParty::Request.new http_method, path, safe_req_options\n req_for_airbrake = { :method => http_method, :path => path, :options => safe_req_options }\n\n begin\n response = req.perform\n rescue => ex\n raise CityGridExceptions::RequestError.new req_for_airbrake, ex\n ensure\n if CityGrid.print_curls? \n if defined?(Rails.logger)\n Rails.logger.info req_to_output.to_curl\n else\n puts req_to_output.to_curl\n end\n end\n end\n\n \n begin \n # catch unparsable responses (html etc)\n if !response.parsed_response.is_a?(Hash)\n #pp \"[gem] the response was unparsable (response was not a hash)\"\n raise CityGridExceptions::ResponseParseError.new req_for_airbrake, response\n # catch responses not in new response format\n elsif response[\"errors\"]\n #pp \"[gem] An error in the old response format was caught. Raising a general response error...\"\n raise CityGridExceptions::ResponseError.new req_for_airbrake, response[\"errors\"], response\n\n # Parse and handle new response codes \n elsif (response[\"response\"] && response[\"response\"][\"code\"] != \"SUCCESS\") && \n (response[\"response\"] && response[\"response\"][\"code\"] != 200) && \n (response[\"response\"] && response[\"response\"][\"code\"] != 400) \n error_code = response[\"response\"][\"code\"]\n #pp \"[gem] The response was contained in the first level of the response hash. Below:\"\n #pp response\n #pp \"found error code: #{error_code}\"\n #pp \"****************************************************************************\"\n raise CityGridExceptions.appropriate_error(error_code).new req_for_airbrake, response, response[\"response\"][\"message\"].to_s #+ \" \" + CityGridExceptions.print_superclasses(error_code)\n # if the response is a nested hash/nested hash containing arrays\n elsif response[\"totalNumEntries\"] && response[\"response\"].nil?\n #pp \"[gem] now parsing a response with multiple entries: #{response}\"\n error_code = parse_multiple_responses(response)\n #pp \"the error code that came back is #{error_code}\"\n if error_code.nil? || error_code == []\n #pp \"[gem] passing over this for now\"\n return CityGrid::API::Response.new response # pass over for now\n elsif error_code[0] == \"SUCCESS\" || error_code[0] == 200 || error_code[0] == 400\n return CityGrid::API::Response.new response\n else \n #pp \"[gem] we found an error and it was #{error_code[1]}\"\n raise CityGridExceptions.appropriate_error(error_code[0]).new req_for_airbrake, response, error_code[1].to_s + \" \"# + CityGridExceptions.print_superclasses(error_code[0])\n end\n else\n return CityGrid::API::Response.new response\n end\n rescue => ex\n pp \"The gem threw an error: #{ex}\"\n raise ex if CityGrid.raise_errors?\n end\n end",
"def api_request(&block)\n response = begin\n block.call([])\n rescue RestClient::Exception => e\n if e.http_code == 401 # raise exception in case of token expiration\n raise e\n else\n e.response\n end\n end\n\n parse_and_format_response response\n end",
"def github_client_request(client, id, **options)\n GitHub::Errors.with_error_handling { client.send(github_type, id, options) }\n rescue GitHub::Error\n nil\n end",
"def request(method, url = nil, options = {})\n options[:headers] = {'Content-Type' => 'application/json'}.merge(options[:headers] || {})\n options[:body] = options[:body].to_json if options[:body].is_a?(Hash)\n\n # Adopt Google's API erorr handling recommendation here:\n # https://developers.google.com/drive/handle-errors#implementing_exponential_backoff\n #\n # In essence, we try 5 times to perform the request. With each subsequent request,\n # we wait 2^n seconds plus a random number of milliseconds (no greater than 1 second)\n # until either we receive a successful response, or we run out of attempts.\n # If the Retry-After header is in the error response, we use whichever happens to be\n # greater, our calculated wait time, or the value in the Retry-After header.\n #\n # If development_mode is set to true, we only run the request once. This speeds up\n # development for those using this gem.\n attempt = 0\n max_attempts = GoogleAPI.development_mode ? 1 : 5\n while attempt < max_attempts\n response = access_token.send(method.to_sym, url, options)\n seconds_to_wait = [((2 ** attempt) + rand), response.headers['Retry-After'].to_i].max\n attempt += 1\n break if response.status < 400 || attempt == max_attempts\n GoogleAPI.logger.error \"Request attempt ##{attempt} to #{url} failed for. Trying again in #{seconds_to_wait} seconds...\"\n sleep seconds_to_wait\n end\n\n response.parsed || response\n end",
"def request(api_method, parameters, body_object = nil, media = nil)\n client_parms = {\n :api_method => api_method,\n :parameters => parameters\n }\n # The Google API complains when given null values for enums, so just don't pass it any null fields\n # XXX It may still balk if we have a nested object, e.g.:\n # {:a_field => \"string\", :a_nested_field => { :an_empty_nested_field => nil } }\n client_parms[:body_object] = body_object.reject { |_k, v| v.nil? } if body_object\n client_parms[:media] = media if media\n\n result = @client.execute(client_parms)\n\n build_excon_response(result.body.nil? || result.body.empty? ? nil : Fog::JSON.decode(result.body), result.status)\n end",
"def request( params={} )\n if Biomart.proxy or ENV['http_proxy']\n proxy_uri = Biomart.proxy\n proxy_uri ||= ENV['http_proxy']\n proxy = URI.parse( proxy_uri )\n @@client = Net::HTTP::Proxy( proxy.host, proxy.port )\n end\n \n params[:url] = URI.escape(params[:url])\n \n if params[:method] === 'post'\n res = @@client.post_form( URI.parse(params[:url]), { \"query\" => params[:query] } )\n else\n res = @@client.get_response( URI.parse(params[:url]) )\n end\n \n # Process the response code/body to catch errors.\n if res.code != \"200\"\n raise HTTPError.new(res.code), \"HTTP error #{res.code}, please check your biomart server and URL settings.\"\n else\n if res.body =~ /ERROR/\n if res.body =~ /Filter (.+) NOT FOUND/\n raise FilterError.new(res.body), \"Biomart error. Filter #{$1} not found.\"\n elsif res.body =~ /Attribute (.+) NOT FOUND/\n raise AttributeError.new(res.body), \"Biomart error. Attribute #{$1} not found.\"\n elsif res.body =~ /Dataset (.+) NOT FOUND/\n raise DatasetError.new(res.body), \"Biomart error. Dataset #{$1} not found.\"\n else\n raise BiomartError.new(res.body), \"Biomart error.\"\n end\n end\n end\n \n return res.body\n end",
"def requestFailed(request)\n error = request.error\n puts \"Error parsing the users API call\"\n # should do something better...\n end",
"def api_request(method, path, opts = {})\n request(method, path, opts)\n end",
"def call_token_fail_api(ticket, reason)\n return call_api(\"/api/auth/token/fail\", {\n \"ticket\" => ticket,\n \"reason\" => reason\n })\nend",
"def api_request_raw(url, media_type = '')\n\n begin\n start_time = Time.now\n\n contents = do_request(url, media_type)\n total = Time.now.to_ms - start_time.to_ms\n info \"Successful request. URL: #{url}, Remaining: #{@remaining}, Total: #{total} ms\"\n\n contents\n rescue OpenURI::HTTPError => e\n @remaining = e.io.meta['x-ratelimit-remaining'].to_i\n @reset = e.io.meta['x-ratelimit-reset'].to_i\n\n case e.io.status[0].to_i\n # The following indicate valid Github return codes\n when 400, # Bad request\n 403, # Forbidden\n 404, # Not found\n 409, # Conflict -- returned on gets of empty repos\n 422 then # Unprocessable entity\n warn request_error_msg(url, e)\n return nil\n when 401 # Unauthorized\n warn request_error_msg(url, e)\n warn \"Unauthorised request with token: #{@token}\"\n raise e\n when 451 # DMCA takedown\n warn request_error_msg(url, e)\n warn \"Repo was taken down (DMCA)\"\n return nil\n else # Server error or HTTP conditions that Github does not report\n warn request_error_msg(url, e)\n raise e\n end\n rescue StandardError => e\n warn error_msg(url, e)\n raise e\n ensure\n # The exact limit is only enforced upon the first @reset\n # No idea how many requests are available on this key. Sleep if we have run out\n if @remaining < @req_limit\n to_sleep = @reset - Time.now.to_i + 2\n warn \"Request limit reached, reset in: #{to_sleep} secs\"\n t = Thread.new do\n slept = 0\n while true do\n debug \"Sleeping for #{to_sleep - slept} seconds\"\n sleep 1\n slept += 1\n end\n end\n sleep([0, to_sleep].max)\n t.exit\n end\n end\n end",
"def request(type, id=\"\", params=\"\")\n id = id.to_s\n params = params.to_s\n api_path = case type\n when \"orders\"\n \"/api/v2/orders?\"\n when \"order_metadata\"\n raise \"ID required\" if id.empty?\n \"/api/v2/orders/#{id}?\"\n when \"shop_metadata\"\n raise \"ID required\" if id.empty?\n \"/api/v2/shop/#{id}?\"\n end\n api_path.chop! if params.empty?\n\n response = HTTParty.get(\n @domain + api_path + params, \n basic_auth: @auth\n )\n response_valid?(response)\n response\nend",
"def test_get_request_error_417\n\n stub_request(:get, \"https://start/hey\").\n with(:headers => {'Accept' => 'application/json', 'Accept-Encoding' => 'gzip, deflate', 'Authorization' => 'Bearer sweet!'}).\n to_return(:status => 417, :body => \"\", :headers => {})\n\n a = Hash['api_prefix' => \"https://start\",\n 'key' => 'key',\n 'secret' => 'secret',\n 'token_server' => 'nowhere.edu',\n 'token' => 'sweet!'\n ]\n h = WAPI.new(a);\n\n r = h.get_request(\"/hey\")\n\n assert_equal(r.meta_status, 666, \"didn't get wrapped exception\")\n exp = r.result\n assert_equal(exp.http_code, 417, \"got incorrect wrapped exception\")\n\n end",
"def make_http_request( url, options, auth_info = {} )\n try_count = 0\n \n begin\n request = Net::HTTP::Post.new(url.path)\n request.basic_auth auth_info[:hapi_username], auth_info[:hapi_password] unless auth_info.empty?\n request.set_form_data(options)\n request.add_field('User-Agent', USER_AGENT)\n \n http = Net_HTTP.new(url.host, url.port)\n http.use_ssl = true\n http.request(request)\n rescue Errno::ECONNREFUSED\n if try_count < 2\n try_count += 1\n sleep 1\n retry\n else\n raise Backend, \"Connection refused trying to contact hAPI at #{@hapi_hostname}\"\n end\n end\n end",
"def request(method, path, params)\n params ||= {}\n uri = full_url(path)\n\n Trubl.logger.info(\"Trubl::Client #{method}-ing #{uri} with params #{params.merge(headers: headers)}\")\n response = HTTMultiParty.send(method, uri, params.merge(headers: headers))\n\n if !response.code =~ /20[0-9]/\n Trubl.logger.fatal(\"Trubl::Client #{response.code} #{method}-ing #{uri.to_s} #{response.parsed_response}\")\n else\n Trubl.logger.debug(\"Trubl::Client #{uri} response: #{response.body}\")\n end\n response.body.force_encoding(\"utf-8\") if response.body and response.body.respond_to?(:force_encoding)\n response\n end",
"def send_error_to_slack\n send_request_to_slack(make_error_response)\n end",
"def invoke_request(url)\n site = RestClient::Resource.new(url, \"dHgVM1emGoTyr8zHmVNH\")\n\n begin\n response = site.get(:accept=>\"application/json\")\n # puts \"URL response: #{response}\"\n return JSON.parse(response)\n rescue => e\n e.response\n return nil\n end\nend",
"def perform_request\n\t\t# If this is set within the begin block, it will reset 'retries' with every retry\n\t\tsleep_sec = 1\n\t\tretries = 3\n\t\tbegin\n\t\t\t# Can we check if configuration is a valid object of class OzRequestConfiguration?\n\t\t\turl = \"localhost:3000/v1.0\"+path\n\t\t\tcurl_instance.url = url\n\t\t\tcurl_instance.headers = {}.merge!(headers)\n\t\t\t#configuration.config_request(self)\n\n\t\t\tcase method\n\t\t\t\twhen :get\n\t\t\t\t\tcurl_instance.http_get\n\t\t\t\twhen :head\n\t\t\t\t\tcurl_instance.http_head\n\t\t\t\twhen :put\n\t\t\t\t\tcurl_instance.http_put(req_body)\n\t\t\t\twhen :post\n\t\t\t\t\tcurl_instance.http_post(req_body)\n\t\t\t\twhen :delete\n\t\t\t\t\tcurl_instance.http_delete\n\t\t\t\telse\n\t\t\t\t\traise NotImplementedError.new(\"Unsupported http method #{method}\")\n\t\t\tend\n\n\t\t\tresponse = UserHTTPResponse.new(curl_instance)\n\t\t\tresponse\n\t\trescue NotImplementedError => e\n\t\t\traise e\n\t\trescue Curl::Err::TimeoutError, Curl::Err::GotNothingError, Curl::Err::HostResolutionError, Request5xxException => e\n\t\t\tif retries > 0\n\t\t\t\tperform_sleep(sleep_sec)\n\t\t\t\tretries -= 1\n\t\t\t\tsleep_sec *= 2\n\t\t\t\tretry\n\t\t\tend\n\t\t\traise e\n\t\trescue Exception => e\n\t\t\traise configuration.api_error_class.new({exception: e.inspect})\n\t\tend\n\tend",
"def request(method, path, opts = {})\n raise ClientError, 'Access token missing' unless @access_token\n\n opts[:headers] = {} if opts[:headers].nil?\n opts[:headers]['Accept'] = 'application/json'\n opts[:headers]['Content-Type'] = 'application/json' unless method == :get\n opts[:headers]['User-Agent'] = user_agent\n opts[:headers]['Authorization'] = \"Bearer #{@access_token}\"\n\n if !opts[:data].nil?\n opts[:body] = opts[:data].to_param\n\n puts \"SETTING BODY #{opts[:body]}\"\n\n opts[:headers]['Content-Type'] = 'application/x-www-form-urlencoded' # sob sob\n end\n\n path = URI.encode(path)\n\n resp = connection.run_request(method, path, opts[:body], opts[:headers]) do |req|\n req.params = opts[:params] if !opts[:params].nil?\n end\n\n response = Response.new(resp)\n\n case response.status\n when 301, 302, 303, 307\n # TODO\n when 200..299, 300..399\n # on non-redirecting 3xx statuses, just return the response\n response\n when 400..599\n error = ApiError.new(response)\n raise(error, \"Status code #{response.status}\")\n else\n error = ApiError.new(response)\n raise(error, \"Unhandled status code value of #{response.status}\")\n end\n end",
"def error!(error_hash = {}, status_code = 500)\n raise Errors::ApiError.new(error_hash, status_code)\n end",
"def request(method, message = nil)\n @client.call(method, message:)\n end",
"def call_api(**rest_options)\n @retry.do do\n res = RestClient::Request.execute(**rest_options)\n json = res && !res.empty? ? ::JSON.parse(res.to_s) : nil\n call_api_response(res) if respond_to?(:call_api_response)\n [res, json]\n end\n end",
"def call(url:, action: :get, **options)\n response = client.send(action, url, options[:body], 'Content-Type': 'application/json')\n\n unless response.success?\n Rails.logger.info(\"#API response fail: #{response.inspect}\")\n raise ::Errors::BadRequest\n end\n\n return JSON.parse response.body if response.status == 200\n end",
"def request(method, url, payload, format)\n opts = {\n :method => method,\n :url => url,\n :payload => payload,\n :headers => {:content_type => CONTENT_TYPES[format]},\n :timeout => TIMEOUT,\n :open_timeout => OPEN_TIMEOUT\n }\n \n RestClient::Request.execute(opts)\n end",
"def request(api_method, params = {}, request_method = :get)\n self.params = params.merge(method: api_method, format: 'json')\n self.request_method = request_method\n self.header = new_header\n self.typhoeus_request = new_typhoeus_request\n self.response = typhoeus_request.run\n self.body = Oj.load(response.body, OJ_OPTIONS)\n check_response!\n body\n end",
"def call(**params)\n url = construct_url(**full_params(params))\n\n @client.get(url).yield_self do |response|\n guard_errors!(response)\n self.class.parse(response.body)\n end\n rescue API::Error\n raise # Not catching in the next block\n rescue StandardError => e\n raise unless url\n raise API::Error, \"#{e.class} at #{url}: #{e.message}\"\n end",
"def request\n Timeout::timeout(timeout) { @request ||= open(url, {:allow_redirections => allow_redirections, 'User-Agent' => user_agent}) }\n\n rescue TimeoutError\n add_fatal_error 'Timeout!!!'\n rescue SocketError\n add_fatal_error 'Socket error: The url provided does not exist or is temporarily unavailable'\n rescue Exception => e\n add_fatal_error \"Scraping exception: #{e.message}\"\n end",
"def request(url)\n\n # For catch 4xx and 5xx HTTP errors\n has_errors = false\n\n # Send request to vendor API\n http = Curl.get(url) do |http|\n\n # On 4xx errors\n http.on_missing do\n has_errors = true\n end\n\n # On 5xx errors\n http.on_failure do\n has_errors = true\n end\n\n end\n\n raise \"Error from TRADO API - #{http.body_str}\" if has_errors\n\n JSON.parse(http.body_str)['data']\n\n end",
"def request_api(url)\n begin\n response = RestClient.get(url)\n print(\"response: \", response)\n JSON.parse(response)\n rescue\n return nil\n end\n \n \n end",
"def make_request_get_response_trend_availible\n @path_trend_availible = '/1.1/trends/available.json'\n @address_trend_availible = URI(\"#{@baseurl}#{@path_trend_availible}\")\n # Set up HTTP. Need ssL to make the connection\n @request_trend_availible = Net::HTTP::Get.new @address_trend_availible.request_uri\n @http = Net::HTTP.new @address_trend_availible.host, @address_trend_availible.port\n @http.use_ssl = true\n @http.verify_mode = OpenSSL::SSL::VERIFY_PEER\n # Issue the request.\n @request_trend_availible.oauth! @http, @consumer_key_country, @access_token_country\n @http.start\n @response_trend_availible = @http.request @request_trend_availible\n @response_trend_availible\n end",
"def request(body={}, method_name='', failure_message='', benchmark=true)\n full_body = self.body(method_name).merge(body)\n options = {\n :http_method => :post,\n :method => method_name,\n :body => Fog::JSON.encode(full_body)\n }\n response = nil\n if benchmark\n time = Benchmark.realtime {\n response = _request(options)\n }\n Fog::Logger.debug(\"#{options[:method]} took: #{time}\")\n else\n response = _request(options)\n end\n if response['Success']\n response\n else\n Fog::Logger.debug(\"Request failed. Debug: #{response}\")\n raise Fog::ArubaCloud::Errors::RequestError.new(failure_message)\n end\n end",
"def handle_request_error(exception)\n end",
"def client_error?; end"
] |
[
"0.69253516",
"0.65905386",
"0.6541506",
"0.6455014",
"0.6446199",
"0.6446199",
"0.64422065",
"0.64416486",
"0.6423835",
"0.63428026",
"0.63072413",
"0.63021266",
"0.62828106",
"0.62677324",
"0.6234778",
"0.6162966",
"0.61435753",
"0.61298525",
"0.612292",
"0.61221504",
"0.61114556",
"0.61114556",
"0.6100871",
"0.6088022",
"0.6084442",
"0.60784847",
"0.60672706",
"0.6059552",
"0.6035825",
"0.6035825",
"0.6032648",
"0.60326344",
"0.6021309",
"0.6014033",
"0.6006689",
"0.5998367",
"0.59975797",
"0.5992739",
"0.59751934",
"0.59744817",
"0.59688056",
"0.59581864",
"0.5953756",
"0.5944443",
"0.5929897",
"0.5927218",
"0.5916245",
"0.59027433",
"0.58936083",
"0.5881992",
"0.5869405",
"0.5856077",
"0.58365893",
"0.58348995",
"0.5834096",
"0.5829891",
"0.5827322",
"0.5825634",
"0.5820012",
"0.5810498",
"0.5809729",
"0.58041656",
"0.5799171",
"0.5795446",
"0.5795399",
"0.5792189",
"0.5791688",
"0.57872075",
"0.57868373",
"0.57850534",
"0.57805705",
"0.57742614",
"0.57674867",
"0.5756039",
"0.5754528",
"0.5753666",
"0.575335",
"0.57449347",
"0.57443184",
"0.5739164",
"0.5730845",
"0.5713602",
"0.57073593",
"0.57045007",
"0.57033205",
"0.57018584",
"0.5696938",
"0.56868505",
"0.56751657",
"0.5674392",
"0.5671973",
"0.56676006",
"0.56632334",
"0.56612897",
"0.5659571",
"0.5658452",
"0.56506556",
"0.56504744",
"0.5643229",
"0.5641812"
] |
0.6396709
|
9
|
handling behaviour based on response code
|
def parse!(response)
case response.code
when 404
raise Rioter::Errors::SummonerNotFound.new
when 403
# TODO: custom errors
raise StandardError.new("Riot error: Forbidden.")
when 429
retry_after = response.headers["Retry-After"]
raise Rioter::Errors::RateLimited.new(msg: "Rate limit reached, retry after: #{retry_after}", retry_after: retry_after)
else
JSON.parse(response.body)
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def handle_status_code(req)\n case req.code\n when 200..204; return\n when 400; raise ResponseError.new req\n when 401; raise ResponseError.new req\n else raise StandardError\n end\n end",
"def response_code; end",
"def response_code; end",
"def response_code; end",
"def response_code; end",
"def handle_response(resp, head_instead: false)\n case resp.code\n when 200, 201\n head_instead ? resp.headers : JSON.parse(resp.body)\n when 202, 204\n true\n when 400\n raise BadRequest, resp\n when 401\n raise NotAllowed, resp\n when 403\n raise NotAuthorized, resp\n when 404\n raise NotFound, resp\n else\n if resp.code >= 500\n raise ServerError, resp\n else\n raise Error, resp\n end\n end\n end",
"def handleHTTPStatus(code)\n case code\n when 200 # Ok\n puts \"HTTP request successful\"\n return true\n when 204\n puts \"HTTP Error: No Content\"\n return false\n when 401\n puts \"HTTP Error: Server rejected authentication.\"\n return false\n else\n puts \"Unhandled HTTP status: #{code}\"\n return false\n end # case code\n end",
"def process_response(response)\n case response.code.to_i\n when 200, 404\n parse_message response.body\n when 401, 500\n error_message = parse_message response.body\n raise \"Unauthorized: #{error_message['error']['message']}\"\n else\n raise \"Response code #{response.code} not recognized\"\n end\n end",
"def handle_response(response)\n case response.code.to_i\n when 200...300\n response\n else\n raise ResponseError.new(response)\n end\n end",
"def handle_response(response)\n case response.code.to_i\n when 301, 302, 303, 307\n raise Redirection, response\n when 200...400\n response\n when 400\n raise ResourceInvalid, response\n when 401\n raise UnauthorizedAccess, response\n when 403\n raise ForbiddenAccess, response\n when 404\n raise ResourceNotFound, response\n when 405\n raise MethodNotAllowed, response\n when 409\n raise ResourceConflict, response\n when 410\n raise ResourceGone, response\n when 422\n raise ResourceInvalid, response\n when 401...500\n raise ClientError, response\n when 500...600\n raise ServerError, response\n else\n raise(ConnectionError.new(response, \"Unknown response code: #{response.code}\"))\n end\n end",
"def handle_response(response)\n case response.code.to_i\n when 200...400\n response\n when 404\n raise NotFoundError.new(response)\n else\n raise ConnectionError.new(response)\n end\n end",
"def handle_response(response)\n case response.code.to_i\n when 200...400\n response\n when 404\n raise NotFoundError.new(response)\n else\n raise ConnectionError.new(response)\n end\n end",
"def handle_response(response)\n case response.code.to_i\n when 301, 302, 303, 307\n raise(Redirection.new(response))\n when 200...400\n response\n when 400\n raise(BadRequest.new(response))\n when 401\n raise(UnauthorizedAccess.new(response))\n when 403\n raise(ForbiddenAccess.new(response))\n when 404\n raise(ResourceNotFound.new(response))\n when 405\n raise(MethodNotAllowed.new(response))\n when 409\n raise(ResourceConflict.new(response))\n when 410\n raise(ResourceGone.new(response))\n when 422\n raise(ResourceInvalid.new(response))\n when 401...500\n raise(ClientError.new(response))\n when 500...600\n raise(ServerError.new(response))\n else\n raise(ConnectionError.new(response, \"Unknown response code: #{response.code}\"))\n end\n end",
"def handle_response(response)\n handler_for_code(response.code).call(response)\n end",
"def handle_response(response) # :nodoc:\n case response.code\n when 400\n #IN CASE WE WANT MORE PRECISE ERROR NAMES\n #data = response.parsed_response\n #case data['code']\n #when 230\n # raise ParameterDataInvalid.new data\n #else\n # raise BadRequest.new data\n #end\n raise BadRequest.new(response.parsed_response)\n when 403\n raise Unauthorized.new(response.parsed_response)\n when 404\n raise NotFound.new\n when 400...500\n raise ClientError.new\n when 500...600\n raise ServerError.new\n else\n response.parsed_response\n end\n end",
"def handle_response(response); end",
"def handle_response(response); end",
"def handle_resp!(resp)\n case resp\n when '201', '202'\n [ true, resp ]\n else\n [ false, resp ]\n end\n end",
"def flex_error_handling\n response.headers['Status'] = interpret_status(200) if response.headers['Status'] == interpret_status(422)\n response.headers['Status'] = interpret_status(200) if response.headers['Status'] == interpret_status(201)\n end",
"def _handle_response(response)\n \n \n # -- MAJOR EXCEPTION handling (authentication)\n \n if (response == Net::HTTPUnauthorized || response.message == 'Unauthorized') ||\n (response && response['status'].to_i == 403 && response['message'] == \"Access to group-memberships denied\")\n raise APIAuthError.new\n \n \n # -- STANDARD handling\n \n else\n \n hashed_response = nil\n \n # Check if the 'response.body' starts with an '<?xml' tag -> indicating it's XML structure\n if response.body =~ /\\A<\\?xml/ \n hashed_response = Hash.from_xml(response.body)\n else\n hashed_response = hash_a_json(response.body)\n end\n \n # -- Bad request (e.g. posting duplicate content)\n \n \n \n _res = { :response_http_object => response }\n \n \n # -- Bad request (e.g. posting duplicate content)\n \n if response == Net::HTTPBadRequest || response.message == \"Bad Request\" || response.code == 400\n _res[:status] = \"bad_request\"\n _res[:response_object] = hashed_response\n \n \n # -- API SERVICE ERROR\n \n elsif response == Net::HTTPInternalServerError || response.message == 'Internal Server Error' || response.code == 500\n _res[:status] = \"api_service_error\"\n _res[:response_object] = hashed_response\n \n \n # -- FORBIDDEN -> trying to use a resource the user is not allowed, store the 'body' as plain XML at this point\n \n elsif response == Net::HTTPForbidden || response.message == 'Forbidden'\n _res[:status] = \"denied_access\" # e.g. post to LinkedIn group required moderation by an admin\n _res[:response_object] = hashed_response\n \n # Check if additional permissions are required (SHARING)\n if _res[:response_object]['error']['message'] == 'Access to posting shares denied'\n raise APIAuthError.new\n end\n \n \n # -- POST / PUT\n \n elsif response.body.blank? || (response.body.nil? && response.code == 204) # A response without content -> successful \n _res[:status] = \"updated_successfully\"\n \n if response.body.blank?\n _res[:response_object] = {}\n else\n _res[:response_object] = hashed_response\n end\n \n \n # -- GET\n \n else\n _res[:status] = \"retrieved_successfully\"\n _res[:response_object] = hashed_response\n \n end\n \n end\n \n \n _res\n \n end",
"def handle_response(response)\n case response.code\n when 200..299\n response\n else\n if response.request.format == :json\n raise FreebaseAPI::ServiceError.new(response['error'])\n else\n raise FreebaseAPI::NetError.new('code' => response.code, 'message' => response.response.message)\n end\n end\n end",
"def status_code; end",
"def send_by_code request, response, code, headers = {}\n\t\t\t\tbegin\n\t\t\t\t\tresponse.status = code\n\t\t\t\t\theaders.each {|k, v| response[k] = v}\n\t\t\t\t\treturn ErrorCtrl.new(request, response).index\n\t\t\t\trescue => e\n\t\t\t\t\tPlezi.error e\n\t\t\t\tend\n\t\t\t\tfalse\n\t\t\tend",
"def handle_response(res)\n if res.code.to_i == 201\n return res['Location']\n elsif [200,203,204,302].detect { |d| d == res.code.to_i }\n if res.body\n begin\n return JSON.load(res.body)\n rescue => e\n return res\n end\n else\n return res\n end\n else \n raise \"invalid response HTTP code: #{res.code.to_i}, #{res.code}, #{res.body}\"\n end\n end",
"def handle_response(response)\n case response[:status]\n when :success, :created\n self.instance_variable_set('@notsaved', false)\n true\n when :errors\n Amfetamine.logger.warn \"Errors from response\\n #{response[:body]}\"\n response[:body].each do |attr, error_messages|\n error_messages.each do |msg|\n errors.add(attr.to_sym, msg)\n end\n end\n false\n when :server_error\n Amfetamine.logger.warn \"Something went wrong at the remote end.\"\n false\n end\n end",
"def handle_response(request, response)\n case response.code.to_i\n when 301,302\n raise(Redirection.new(request, response))\n when 200...400\n response\n when 400\n raise(BadRequest.new(request, response))\n when 401\n raise(UnauthorizedAccess.new(request, response))\n when 403\n raise(ForbiddenAccess.new(request, response))\n when 404\n raise(ResourceNotFound.new(request, response))\n when 405\n raise(MethodNotAllowed.new(request, response))\n when 409\n raise(ResourceConflict.new(request, response))\n when 412\n raise(PreconditionFailed.new(request, response))\n when 422\n raise(ResourceInvalid.new(request, response))\n when 401...500\n raise(ClientError.new(request, response))\n when 500...600\n raise(ServerError.new(request, response))\n else\n raise(ConnectionError.new(request, response, \"Unknown response code: #{response.code}\"))\n end\n begin\n if response.body.blank?\n nil\n else\n hash = JSON(response.body)\n normalize_hash(hash)\n end\n rescue JSON::ParserError => e\n raise(ConnectionError.new(request, response, \"Invalid json response: #{e.body}\"))\n end\n end",
"def analyse_http_code(response_code)\n case response_code\n when 1 then\n # Failure to use the proxy\n return false\n when 400 .. 403 then\n # Proxy asks for authentication\n return false\n when 407 then\n # Proxy asks for authentication\n return false\n when 444 then\n return response_code\n else\n # If we get a valid return code, we add it to the final list\n return response_code\n end\n end",
"def prepare_status_response( txn, status_code, message )\n\t\tself.log.info \"Non-OK response: %d (%s)\" % [ status_code, message ]\n\n\t\ttxn.status = status_code\n\n\t\t# Some status codes allow explanatory text to be returned; some forbid it.\n\t\tunless BODILESS_HTTP_RESPONSE_CODES.include?( status_code )\n\t\t\ttxn.content_type = 'text/plain'\n\t\t\treturn message.to_s\n\t\tend\n\n\t\t# For bodiless responses, just tell the dispatcher that we've handled \n\t\t# everything.\n\t\treturn true\n\tend",
"def handle_response(response)\n case response.code.to_i\n when 200\n JSON.parse(response.body)['holidays']\n when 400\n raise BadRequest.new response.parsed_response\n when 401\n raise Unauthorized.new\n when 404\n raise NotFound.new\n when 400...500\n raise ClientError.new response.parsed_response\n when 500...600\n raise ServerError.new\n else\n response\n end\n end",
"def handle_response(result)\n unless result.success\n #if result.error_class\n # TODO needs to be constantized first (see TODO in lib/rjr/message)\n # raise result.error_class.new(result.error_msg) unless result.success\n #else\n fail result.error_msg\n #end\n end\n return result.result\n end",
"def handle_response(response, expected = nil)\n response.value\n # todo: pick a better exception\n raise \"Expected a #{expected} response\" if expected and expected != response.code.to_i\n response\n end",
"def handle_response(response)\n begin\n if ok?(response.code)\n if response.body.present?\n parse_response_body(response.body)\n else\n true # blank body\n end\n else\n Rails.logger.error \"Unexpected response #{response.code}, not sure what to do here...\"\n response.message\n end\n rescue => e\n # don't report, just return\n response.message\n end\n end",
"def guess_status(response)\n result = {}\n # response status code returned by php-simple-proxy and php-json-proxy\n if response =~ /\"status\":{\"http_code\":([\\d]+)}/\n result['code'] = $1\n result['message'] = ''\n # generic page titles containing HTTP status\n elsif response =~ />301 Moved</ || response =~ />Document Moved</ || response =~ />Object Moved</ || response =~ />301 Moved Permanently</\n result['code'] = 301\n result['message'] = 'Document Moved'\n elsif response =~ />302 Found</ || response =~ />302 Moved Temporarily</\n result['code'] = 302\n result['message'] = 'Found'\n elsif response =~ />400 Bad Request</\n result['code'] = 400\n result['message'] = 'Bad Request'\n elsif response =~ />401 Unauthorized</\n result['code'] = 401\n result['message'] = 'Unauthorized'\n elsif response =~ />403 Forbidden</\n result['code'] = 403\n result['message'] = 'Forbidden'\n elsif response =~ />404 Not Found</\n result['code'] = 404\n result['message'] = 'Not Found'\n elsif response =~ />The page is not found</\n result['code'] = 404\n result['message'] = 'Not Found'\n elsif response =~ />413 Request Entity Too Large</\n result['code'] = 413\n result['message'] = 'Request Entity Too Large'\n elsif response =~ />500 Internal Server Error</\n result['code'] = 500\n result['message'] = 'Internal Server Error'\n elsif response =~ />503 Service Unavailable</\n result['code'] = 503\n result['message'] = 'Service Unavailable'\n # getaddrinfo() errors\n elsif response =~ /getaddrinfo: /\n if response =~ /getaddrinfo: nodename nor servname provided/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /getaddrinfo: Name or service not known/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n end\n # getnameinfo() errors\n elsif response =~ /getnameinfo failed: /\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # PHP 'failed to open stream' errors\n elsif response =~ /failed to open stream: /\n # HTTP request failed! HTTP/[version] [code] [message]\n if response =~ %r{failed to open stream: HTTP request failed! HTTP\\/(0\\.9|1\\.0|1\\.1) ([\\d]+) }\n result['code'] = $2.to_s\n result['message'] = ''\n if response =~ %r{failed to open stream: HTTP request failed! HTTP/(0\\.9|1\\.0|1\\.1) [\\d]+ ([a-zA-Z ]+)}\n result['message'] = $2.to_s\n end\n # No route to host\n elsif response =~ /failed to open stream: No route to host in/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # Connection refused\n elsif response =~ /failed to open stream: Connection refused in/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # Connection timed out\n elsif response =~ /failed to open stream: Connection timed out/\n result['code'] = 504\n result['message'] = 'Timeout'\n # Success - This likely indicates an SSL/TLS connection failure\n elsif response =~ /failed to open stream: Success in/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n end\n # Java 'java.net' exceptions\n elsif response =~ /java\\.net\\.[^\\s]*Exception: /\n if response =~ /java\\.net\\.ConnectException: No route to host/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /java\\.net\\.ConnectException: Connection refused/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /java\\.net\\.ConnectException: Connection timed out/\n result['code'] = 504\n result['message'] = 'Timeout'\n elsif response =~ /java\\.net\\.UnknownHostException: Invalid hostname/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /java\\.net\\.SocketException: Network is unreachable/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /java\\.net\\.SocketException: Connection reset/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /java\\.net\\.SocketTimeoutException: Connection timed out/\n result['code'] = 504\n result['message'] = 'Timeout'\n end\n # C errno\n elsif response =~ /\\[Errno -?[\\d]{1,5}\\]/\n if response =~ /\\[Errno -2\\] Name or service not known/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /\\[Errno 101\\] Network is unreachable/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /\\[Errno 104\\] Connection reset by peer/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /\\[Errno 110\\] Connection timed out/\n result['code'] = 504\n result['message'] = 'Timeout'\n elsif response =~ /\\[Errno 111\\] Connection refused/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /\\[Errno 113\\] No route to host/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /\\[Errno 11004\\] getaddrinfo failed/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /\\[Errno 10053\\] An established connection was aborted/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /\\[Errno 10054\\] An existing connection was forcibly closed/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /\\[Errno 10055\\] An operation on a socket could not be performed/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /\\[Errno 10060\\] A connection attempt failed/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /\\[Errno 10061\\] No connection could be made/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n end\n # Python urllib errors\n elsif response =~ /HTTPError: HTTP Error \\d+/\n if response =~ /HTTPError: HTTP Error 400: Bad Request/\n result['code'] = 400\n result['message'] = 'Bad Request'\n elsif response =~ /HTTPError: HTTP Error 401: Unauthorized/\n result['code'] = 401\n result['message'] = 'Unauthorized'\n elsif response =~ /HTTPError: HTTP Error 402: Payment Required/\n result['code'] = 402\n result['message'] = 'Payment Required'\n elsif response =~ /HTTPError: HTTP Error 403: Forbidden/\n result['code'] = 403\n result['message'] = 'Forbidden'\n elsif response =~ /HTTPError: HTTP Error 404: Not Found/\n result['code'] = 404\n result['message'] = 'Not Found'\n elsif response =~ /HTTPError: HTTP Error 405: Method Not Allowed/\n result['code'] = 405\n result['message'] = 'Method Not Allowed'\n elsif response =~ /HTTPError: HTTP Error 410: Gone/\n result['code'] = 410\n result['message'] = 'Gone'\n elsif response =~ /HTTPError: HTTP Error 500: Internal Server Error/\n result['code'] = 500\n result['message'] = 'Internal Server Error'\n elsif response =~ /HTTPError: HTTP Error 502: Bad Gateway/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n elsif response =~ /HTTPError: HTTP Error 503: Service Unavailable/\n result['code'] = 503\n result['message'] = 'Service Unavailable'\n elsif response =~ /HTTPError: HTTP Error 504: Gateway Time-?out/\n result['code'] = 504\n result['message'] = 'Timeout'\n end\n # Ruby exceptions\n elsif response =~ /Errno::[A-Z]+/\n # Connection refused\n if response =~ /Errno::ECONNREFUSED/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # No route to host\n elsif response =~ /Errno::EHOSTUNREACH/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # Connection timed out\n elsif response =~ /Errno::ETIMEDOUT/\n result['code'] = 504\n result['message'] = 'Timeout'\n end\n # ASP.NET System.Net.WebClient errors\n elsif response =~ /System\\.Net\\.WebClient/\n # The remote server returned an error: ([code]) [message].\n if response =~ /WebException: The remote server returned an error: \\(([\\d+])\\) /\n result['code'] = $1.to_s\n result['message'] = ''\n if response =~ /WebException: The remote server returned an error: \\(([\\d+])\\) ([a-zA-Z ]+)\\./\n result['message'] = $2.to_s\n end\n # Could not resolve hostname\n elsif response =~ /WebException: The remote name could not be resolved/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # Remote server denied connection (port closed)\n elsif response =~ /WebException: Unable to connect to the remote server/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # This likely indicates a plain-text connection to a HTTPS or non-HTTP service\n elsif response =~ /WebException: The underlying connection was closed: An unexpected error occurred on a receive/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # This likely indicates a HTTPS connection to a plain-text HTTP or non-HTTP service\n elsif response =~ /WebException: The underlying connection was closed: An unexpected error occurred on a send/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # The operation has timed out\n elsif response =~ /WebException: The operation has timed out/\n result['code'] = 504\n result['message'] = 'Timeout'\n end\n # Generic error messages\n elsif response =~ /(Connection refused|No route to host|Connection timed out) - connect\\(\\d\\)/\n # Connection refused\n if response =~ /Connection refused - connect\\(\\d\\)/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # No route to host\n elsif response =~ /No route to host - connect\\(\\d\\)/\n result['code'] = 502\n result['message'] = 'Bad Gateway'\n # Connection timed out\n elsif response =~ /Connection timed out - connect\\(\\d\\)/\n result['code'] = 504\n result['message'] = 'Timeout'\n end\n end\n result\n end",
"def validate_response(response) \n case response.code\n when '200' \n return\n when '400' # Bad Request error - invalid request\n raise ResponseError::BadRequestError.new(extact_error_message(response.body))\n when '401' # Unauthorised error\n raise ResponseError::UnauthorisedError.new(extact_error_message(response.body))\n when '403' # Forbidden error - valid request but server is refusing, may be due to lack of permissions (RETRY enabled)\n raise ResponseError::ForbiddenError.new(extact_error_message(response.body))\n when '404' # Not Found error - server is unable to locate the resource to serve\n raise ResponseError::NotFoundError.new(extact_error_message(response.body))\n when '500' # Internal Server error - error due to unknown reason\n raise ResponseError::InternalServerError.new(extact_error_message(response.body))\n when '502' # Bad Gateway error - error due to not receiving valid response from backend server \n raise ResponseError::BadGatewayError.new(extact_error_message(response.body))\n when '503' # Service Unavailable error - server is overloded or under maintainance (RETRY enabled)\n raise ResponseError::ServiceUnavailableError.new(extact_error_message(response.body))\n when '504' # Gateway Timeout error - not receiving response within the allowed time period (RETRY enabled)\n raise ResponseError::GatewayTimeoutError.new(extact_error_message(response.body))\n else\n raise ResponseError::UnexpectedError.new(extact_error_message(response.body))\n end\n end",
"def type\n case code\n when 100..199 then :informational_response\n when 200..299 then :success\n when 300..399 then :redirection\n when 400..499 then :client_error\n when 500..599 then :server_error\n else :unknown\n end\n end",
"def handle_response(res)\n # relogin if needed\n return relogin if should_relogin(res)\n\n check_unauthorized(res.status, res.env.url.to_s)\n check_not_found(res.status)\n check_not_success(res.status)\n handle_success(res.body) do |json_body|\n yield(json_body) if block_given?\n end\n end",
"def processresponse(httpresponse)\n\n @responsecode = httpresponse.code\n case httpresponse.code\n when 201 # success condition\n @response = httpresponse.headers[:location]\n when 200 # success condition\n @response = httpresponse.headers[:location]\n\n end\n\n end",
"def process_response(response)\n case response\n when Net::HTTPFound, Net::HTTPCreated\n response['Location']\n when Net::HTTPConflict\n raise URLConflict\n when Net::HTTPNotAcceptable\n raise URLFormatError\n else\n raise InvalidResponse.new(\"Invalid Shorty Response Code: #{response.code} #{response.message}\")\n end\n end",
"def code\n response&.code\n end",
"def handle_response\n unless performed?\n if @error.present?\n handle_error(@error)\n else\n respond_with do |format|\n # Browser scope.\n format.html do\n handle_response_html\n end\n # Rails remote form.\n format.js do\n handle_response_js\n end\n # API / xhr scope.\n format.json do\n handle_response_json\n end\n end\n end\n end\n end",
"def get_http_response_code\n raise 'To be implemented in child classes'\n end",
"def get_response_status(response)\n case response\n when Net::HTTPSuccess\n :ok\n when Net::HTTPRedirection\n :multiple_choices\n when Net::HTTPNotFound\n :not_found\n when Net::HTTPClientError\n :bad_request\n when Net::HTTPServerError\n :internal_server_error\n else\n :bad_request\n end\n end",
"def response_to_status(response)\n response ? :success : :error\n end",
"def handle_response(response, used_by)\n if Utils.is_success_status_code(response.code)\n if response.body.nil? || response.body == ''\n nil\n else\n JSON.parse(response.body)\n end\n elsif Utils.is_under_maintenance_response(response.code)\n raise UnderMaintenanceException.new.reason\n elsif Utils.is_rate_limit_response(response.code)\n raise RateLimitException.new.reason\n else\n _err_message = '---------Copyleaks SDK Error (' + used_by + ')---------' + \"\\n\\n\"\n _err_message += 'status code: ' + response.code + \"\\n\\n\"\n\n _err_message += 'response body:' + \"\\n\" + response.body.to_json + \"\\n\\n\" unless response.body.nil?\n\n _err_message += '-------------------------------------'\n raise CommandException.new(_err_message).reason + \"\\n\"\n end\n end",
"def http_response_code(status = nil)\n if status\n @status = status\n else\n @status\n end\n end",
"def process_response(obj)\n end",
"def status code=nil\n @response.status = code if code\n @response.status\n end",
"def ok; @status = 200 end",
"def ok; @status = 200 end",
"def handle_error (url, res)\n puts \"#{url} was not found\" if res.code.to_i == 404\n puts \"#{url} requires authorization\" if res.code.to_i == 401\n puts \"#{url} returns an application error\" if res.code.to_i == 500\nend",
"def validate_response(response) # :nodoc:\n code = response.code.to_i\n raise HttpError, \"#{code} #{response.msg}\" if code < 200 || code > 299\n end",
"def status_code\n params[:code] || 500\n end",
"def status_code\n params[:code] || 500\n end",
"def ok_status_code\n _undefined\n end",
"def handleResult(response)\n response = JSON.parse(response, :symbolize_names => true)\n case response[:code]\n when CODE_OK then response[:data]\n when CODE_INVALID_PARAMETERS, CODE_INVALID_API_KEY, CODE_INVALID_METHOD\n raise ArgumentError, response[:message]\n else\n raise StandardError, \"An unknown error ocurrced while handling the response: #{response.to_s}\"\n end\n end",
"def process_response(cgi_response, ssb_response)\n case\n when ssb_response.nil?\n ['response is nil', 'N/A']\n when ssb_response.instance_of?(String)\n string_response(cgi_response, ssb_response)\n when ['301', '302'].include?(ssb_response.code)\n redirect_response(cgi_response, ssb_response)\n else\n ok_response(cgi_response, ssb_response)\n end\n end",
"def respond_with(status_code)\n response.status = status_code\n response.write \"\"\n nil\n end",
"def status(code)\n @response.status = code\n end",
"def status(code)\n response.status = code\n end",
"def response_code\n @response.code\n end",
"def throw(code)\n status(*Http::Status.for_code(code))\n super :halt\n end",
"def handle_response(response, required_root_key = nil)\n # at this point the FaradayMiddleware::ParseXml or JSON should have parsed\n # all valid responses into a Hash\n if response.env[:method] != :delete && !response.body.is_a?(Hash)\n raise Errors::ResponseError, 'Unexpected or empty response'\n end\n\n case response.status\n when 401\n raise Errors::AuthenticationError, response['technical_message']\n when 500\n raise Errors::SystemError, response.body\n else\n if required_root_key\n response_data_for_key!(response.body, required_root_key)\n else\n response.body\n end\n end\n end",
"def handler\n Proc.new do |response|\n case response.code\n when 200..204\n response\n when 400\n raise Jiralicious::TransitionError.new(response.inspect)\n when 404\n raise Jiralicious::IssueNotFound.new(response.inspect)\n else\n raise Jiralicious::JiraError.new(response.inspect)\n end\n end\n end",
"def response?(params)\n params.key?('responseStatusCode') || params.key?('responseErrorReason')\n end",
"def process_response(response)\n case response\n when Net::HTTPSuccess\n JSON.parse response.body\n when Net::HTTPUnauthorized\n { 'error' => \"#{response.message}:\n username and password set and correct?\" }\n when Net::HTTPServerError\n { 'error' => \"#{response.message}: try again later?\" }\n else\n { 'error' => response.message }\n end\n end",
"def parse_response_line\n if @headers.first =~ /\\AHTTP\\/1\\.[01] ([\\d]{3})/\n @status = $1.to_i\n else\n set_deferred_status :failed, {\n :status => 0 # crappy way of signifying an unrecognized response. TODO, find a better way to do this.\n }\n close_connection\n end\n end",
"def handle_response(response)\n type, msgid, error, result = response\n if observable = @requests[msgid]\n @requests[msgid].set_response(result, error)\n else\n warn \"unknown response with id=#{msgid}\"\n end\n end",
"def respond_bad_request; make_response(nil, false, 400, \"Bad Request\") end",
"def interpret_response(response)\n case response.code.to_i\n when 200\n puts 'OK'\n when 201,202,204\n puts 'OK'\n return\n when 400\n puts 'Bad request'\n return\n when 404\n puts 'Resource not found'\n return\n when 500\n puts 'Sensu encountered an error'\n return\n else\n puts \"Unexpected HTTP response code #{response.code}\"\n return\n end\n\n return JSON.parse(response.body)\n end",
"def generate_response(code, format)\n @message = \"Returning code #{code} in #{format} format\"\n response_data = case format\n when \"txt\"\n content_type 'text/plain'\n @message\n when \"json\"\n content_type 'application/json'\n { message: @message }.to_json\n when \"xml\"\n content_type 'application/xml'\n erb :'status.xml', layout: false\n else\n erb :status\n end\n [code.to_i, response_data]\nend",
"def status_code\n @response.status\n end",
"def check_response!\n body[:stat] == 'ok' || fail(ClientError, \"#{ body.inspect }\")\n end",
"def process_response!(response)\n\t\t\t\tfinish_request!\n\t\t\t\t\n\t\t\t\tif Exception === response\n\t\t\t\t\t@logger.warn \"[#{@message.id}] Failure while processing response #{response}!\" if @logger\n\t\t\t\t\tRubyDNS.log_exception(@logger, response) if @logger\n\t\t\t\t\t\n\t\t\t\t\ttry_next_server!\n\t\t\t\telsif response.tc != 0\n\t\t\t\t\t@logger.warn \"[#{@message.id}] Received truncated response!\" if @logger\n\t\t\t\t\t\n\t\t\t\t\ttry_next_server!\n\t\t\t\telsif response.id != @message.id\n\t\t\t\t\t@logger.warn \"[#{@message.id}] Received response with incorrect message id: #{response.id}\" if @logger\n\t\t\t\t\t\n\t\t\t\t\ttry_next_server!\n\t\t\t\telse\n\t\t\t\t\t@logger.debug \"[#{@message.id}] Received valid response #{response.inspect}\" if @logger\n\t\t\t\t\t\n\t\t\t\t\tsucceed response\n\t\t\t\tend\n\t\t\tend",
"def status_code_meaning(number)\r\n if number == 200\r\n return \"OK\"\r\n elsif number == 301\r\n return \"Moved Permanently\"\r\n elsif number == 401\r\n return \"Unauthorized\"\r\n elsif number == 404\r\n return \"Not Found\"\r\n elsif number == 500\r\n return \"Internal Server Error\"\r\n end\r\nend",
"def respond_with(status_code)\n response.status = status_code\n response.write ''\n nil\n end",
"def error_response(code, message)\n render :json => {:success=>false,:error_code => code,:error_msg => message}\n end",
"def request_successful(response)\n\t\tresponse.code == \"200\"\n\tend",
"def handle_response(resp)\n self.response = JSON.parse(resp.body, symbolize_names: true)\n\n # :content and :reference must be included in response.\n if response.keys.include?(:content) && response.keys.include?(:reference)\n return\n end\n\n # :content or :reference not included.\n raise ::EasyManageClient::InvalidResponseContent\n end",
"def finish_request\n if (400..499).include? response.code\n set_error_body(response.code)\n end\n end",
"def code\n @response.code\n end",
"def response; end",
"def response; end",
"def response; end",
"def response; end",
"def response; end",
"def response; end",
"def response; end",
"def response; end",
"def response; end",
"def response; end",
"def response; end",
"def response; end",
"def response; end",
"def render_error( status_code )\n\n respond_to do |format|\n\n format.html { render( action: status_code, status: status_code )}\n format.all { head( status_code )}\n\n end\n\n @error_sent = true\n\n true # return something so we can chain things\n\n end",
"def response_ok?(response, request)\n \n # first allow for debugging\n d {request.object_id}\n d {request}\n d {response.object_id}\n d {response.code}\n d {response.headers_hash}\n d {response.body}\n\n case response.code.to_i\n\n when 502, 503, 504\n raise AMEE::ConnectionFailed.new(\"A connection error occurred while talking to AMEE: HTTP response code #{response.code}.\\nRequest: #{request.method.upcase} #{request.url.gsub(request.host, '')}\")\n when 408\n raise AMEE::TimeOut.new(\"Request timed out.\")\n when 404\n raise AMEE::NotFound.new(\"The URL was not found on the server.\\nRequest: #{request.method.upcase} #{request.url.gsub(request.host, '')}\")\n when 403\n raise AMEE::PermissionDenied.new(\"You do not have permission to perform the requested operation.\\nRequest: #{request.method.upcase} #{request.url.gsub(request.host, '')}\\n#{request.body}\\Response: #{response.body}\")\n when 401\n authenticate\n return false\n when 400\n if response.body.include? \"would have resulted in a duplicate resource being created\"\n raise AMEE::DuplicateResource.new(\"The specified resource already exists. This is most often caused by creating an item that overlaps another in time.\\nRequest: #{request.method.upcase} #{request.url.gsub(request.host, '')}\\n#{request.body}\\Response: #{response.body}\")\n else\n raise AMEE::BadRequest.new(\"Bad request. This is probably due to malformed input data.\\nRequest: #{request.method.upcase} #{request.url.gsub(request.host, '')}\\n#{request.body}\\Response: #{response.body}\")\n end\n when 200, 201, 204\n return response\n when 0\n connection_failed\n end\n # If we get here, something unhandled has happened, so raise an unknown error.\n raise AMEE::UnknownError.new(\"An error occurred while talking to AMEE: HTTP response code #{response.code}.\\nRequest: #{request.method.upcase} #{request.url}\\n#{request.body}\\Response: #{response.body}\")\n end",
"def api_response(*args) # :nodoc:\n code = args.first\n args.shift\n\n err = @@ERROR_CODES[code] || @@ERROR_CODES[:unknown]\n render :json => {\n :error => {\n :code => err[0],\n :message => err[1],\n },\n :content => args.first,\n }, :status => err[2]\n end",
"def status_code\n return manual_status_code if manual_status_code\n return 422 if errors.present?\n return 200 if result\n return 400\n end",
"def render_exception_response(exception, response_code)\n case response_code\n when :unauthorized\n logged_in? ? access_denied : must_be_logged_in\n when :forbidden\n access_denied\n when :not_implemented\n not_yet_implemented\n else\n status = interpret_status(response_code) # defaults to \"500 Unknown Status\" if response_code is not recognized\n status_code = status[0,3]\n respond_to do |format|\n format.html do\n @error_page_title = I18n.t(\"error_#{status_code}_page_title\", :default => [:error_default_page_title, \"Error.\"])\n @status_code = status_code\n render :layout => 'v2/errors', :template => 'content/error', :status => status_code\n end\n format.js do\n render :layout => false, :template => 'content/error', :status => status_code\n end\n format.all { render :text => status, :status => status_code }\n end\n end\n end",
"def code\n @raw_response.code\n end",
"def unrecognizedResponse( text )\n end",
"def handle_error_response(response)\n message = code = nil\n if response.include?(\"error\")\n error = response[\"error\"]\n message = (error[\"message\"] || DEFAULT_ERROR)\n code = error[\"code\"]\n else\n message = DEFAULT_ERROR\n end\n log.error \"Error response received from server.\\nMessage: #{message}\\nCode: #{code}\"\n case code\n when \"errors.sessions.authorization_required\"\n raise CAAuthorizationError.new(message, nil, code: code)\n when \"errors.sessions.authentication_required\"\n raise CAAuthenticationError.new(message, nil, code: code)\n else\n raise CAError.new(message, nil, code: code)\n end\n end"
] |
[
"0.78711",
"0.77024347",
"0.77024347",
"0.77024347",
"0.77024347",
"0.7574864",
"0.7558899",
"0.7441638",
"0.74407214",
"0.74375355",
"0.74352586",
"0.74352586",
"0.7407546",
"0.7358558",
"0.7344115",
"0.73034644",
"0.73034644",
"0.7217653",
"0.7124387",
"0.7091345",
"0.70735115",
"0.7066041",
"0.7064417",
"0.70551497",
"0.7039259",
"0.7035644",
"0.6940551",
"0.6931986",
"0.6926609",
"0.6903759",
"0.68737245",
"0.68732196",
"0.6819068",
"0.68162376",
"0.6813541",
"0.6810795",
"0.67981863",
"0.67961997",
"0.6769996",
"0.67334443",
"0.6717266",
"0.671074",
"0.66904366",
"0.66892713",
"0.66811186",
"0.66558605",
"0.66432464",
"0.6641061",
"0.6641061",
"0.6631234",
"0.66262645",
"0.66213936",
"0.66213936",
"0.66129833",
"0.6601987",
"0.6588166",
"0.6579884",
"0.65513647",
"0.65439737",
"0.65421826",
"0.65219724",
"0.6521781",
"0.65215445",
"0.65165997",
"0.65151584",
"0.6514872",
"0.6509849",
"0.650262",
"0.6499009",
"0.6497321",
"0.64969045",
"0.648281",
"0.64777786",
"0.64750904",
"0.6468643",
"0.64666516",
"0.6463382",
"0.64536095",
"0.6443848",
"0.64426404",
"0.6433759",
"0.6433759",
"0.6433759",
"0.6433759",
"0.6433759",
"0.6433759",
"0.6433759",
"0.6433759",
"0.6433759",
"0.6433759",
"0.6433759",
"0.6433759",
"0.6433759",
"0.64238495",
"0.64186287",
"0.6405637",
"0.6389117",
"0.6386998",
"0.6385049",
"0.63711554",
"0.6360213"
] |
0.0
|
-1
|
add screener to playlist
|
def add_screener
@screener_playlist = ScreenerPlaylist.find(params[:id])
@screener_playlist_item_position = ScreenerPlaylistItem.where("screener_playlist_id=?", params[:id])
.order("position ASC")
.find(:last)
@screener_playlist_item_position = @screener_playlist_item_position.nil? ? 1 : @screener_playlist_item_position.position + 1
@screener_playlist_item = ScreenerPlaylistItem.new(screener_playlist_id: params[:id],
screener_id: params[:screener_id],
position: @screener_playlist_item_position)
@notice=""
@screener_to_add = Screener.find(params[:screener_id])
if @screener_playlist_item.save
flash[:notice] = 'Screener was successfully added.'
session[:screeners_search] = collection_to_id_array(@screener_playlist.screeners)
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def add_to_queue(playlist)\n @queue << playlist\n if @current_playlist.nil? \n @current_playlist = @queue.shift\n play @current_playlist\n end\n end",
"def add_to_playlist(media)\n connection.write(\"enqueue #{media(media)}\")\n end",
"def add_to_playlist(media)\n connection.write(\"enqueue #{media_arg(media)}\")\n end",
"def add_song_to_playlist(song)\n if @playlist.include? song\n return #exit out of function if already exits\n end\n @playlist << song #else add song to playlist array\n end",
"def add_song(song)\n songs << song\n end",
"def add_song(song_name)\n songs << song_name\n end",
"def append(opts)\n playlist_control :add, opts\n end",
"def play!\n @playlist.shift\n end",
"def add_song(song)\n songs << song\n end",
"def playlist_end playlist\n end",
"def add(playlist, update_stats=false)\n\t\t\tkparams = {}\n\t\t\tclient.add_param(kparams, 'playlist', playlist);\n\t\t\t# indicates that the playlist statistics attributes should be updated synchronously now\n\t\t\tclient.add_param(kparams, 'updateStats', update_stats);\n\t\t\tclient.queue_service_action_call('playlist', 'add', kparams);\n\t\t\tif (client.is_multirequest)\n\t\t\t\treturn nil;\n\t\t\tend\n\t\t\treturn client.do_queue();\n\t\tend",
"def add_track(new_song)\n if AVAILABLE_SONGS.include?(new_song)\n @playlist << new_song\n else\n return false\n end\n end",
"def add_songs tracklist, playlist_object\n playlist_object.add_tracks!(tracklist)\n end",
"def add_to_spotify\n if self.spotify_id.nil?\n playlist = self.group.owner.rspotify_user.create_playlist!(self.name)\n self.spotify_id = playlist.id\n self.save\n self\n else\n nil\n end\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n @@sounds_count += 1\n\n end",
"def add_song(song)\n @songs << song \n end",
"def add_play(play_class)\n @plays << play_class.new\n end",
"def create_playlist(festival)\n playlist = @spotify_user.create_playlist!(festival.name)\n festival.artists.each do |artist|\n artists = RSpotify::Artist.search(artist.name)\n next if artists.empty?\n top_tracks = artists.first.top_tracks(:US)\n playlist.add_tracks!(top_tracks[0..1]) unless top_tracks.empty?\n end\n playlist\n end",
"def add_song(song)\n\t\t@songs <<(song)\n\t\t\n\tend",
"def add_song(song_instance)\n songs << song_instance\n end",
"def add_song(song)\n @songs << song\n end",
"def add_song(song)\n @songs << song\n end",
"def add_song(song)\n @songs << song\n end",
"def add_song(song)\n @songs << song\n end",
"def add_song(song)\n @songs << song\n end",
"def add_song(song)\n @songs << song\n end",
"def current_playlist\n super || create_current_playlist\n end",
"def add_song\n \t# add this song to the users personal list (history)\n new_song = Song.create(title: params[:title], video_id: params[:video_id], status: \"added to MusiQ!\")\n current_user.songs << new_song\n\n # add this song to the player queue (tracks)\n Track.create(title: params[:title], video_id: params[:video_id], user_id: current_user.id, status: 'waiting')\n redirect_to root_url\n end",
"def add_song(x)\n \t@songs << x\n end",
"def add_song(song)\n @song_list.push(song)\n end",
"def add_song(song_to_be_added)\n @songs << song_to_be_added\n end",
"def initialize(playlist)\n @playlist = playlist\n refresh\n end",
"def add_song(song) #song = #<Song:0x007fc75eb94420 @genre=#<Genre:0x007fc75eb94498 @name=\"rap\", @songs=[]>, @name=\"99 Problems\">\n\n self.songs << song\n end",
"def add(title, artist)\n payload = [{\n action: 'update',\n item: {\n item_id: \"#{title} - #{artist}\",\n song_id: get_song_id(title, artist),\n play_count: 1\n # favorite: true\n }\n }]\n\n ECHONEST.post '/catalog/update', id: id, data: payload.to_json\n end",
"def add_multiple_screeners\n\n @notice = \"\"\n @screener_playlist = ScreenerPlaylist.find(params[:playlist_id])\n screener_ids = params[:screener_ids]\n\n screener_ids.each do |screener_id|\n @screener_playlist_item_position = ScreenerPlaylistItem.where(\"screener_playlist_id=?\", params[:playlist_id])\n .order(\"position ASC\")\n .find(:last)\n @screener_playlist_item_position = @screener_playlist_item_position.nil? ? 1 : @screener_playlist_item_position.position + 1\n @screener_playlist_item = ScreenerPlaylistItem.new(screener_playlist_id: params[:playlist_id],\n screener_id: screener_id,\n position: @screener_playlist_item_position)\n\n @screener_to_add = Screener.find(screener_id)\n if @screener_playlist_item.save\n flash[:notice] = 'Screeners were successfully added.'\n session[:screeners_search] = collection_to_id_array(@screener_playlist.screeners)\n end\n end # loop through video ids\n\n end",
"def add_new_song(new_song)\n @bar_songlist.push(new_song)\n end",
"def add_song(song)\n @songs << song\nend",
"def playlist\n connection.write(\"playlist\")\n end",
"def add_song\n\t\tresponse.headers['Content-Type'] = 'text/javascript' # Tells Rails/Redis that content is JavaScript\n\t\troom = current_user.room\n\t\tnew_song_params = song_params\n\t\tnew_song_params[:added_by] = current_user.username\n\t\t# --- If this is the first song, set it as currently playing ---\n\t\tif room.songs.length == 0\n\t\t\tnew_song_params[:currently_playing] = true\n\t\tend\n\t\t# --- end ---\n\t\tcheck = Song.where(sc_ident: params[:song][:sc_ident])\n\t\tif check.length == 0\n\t\t\t@song = Song.create(new_song_params)\n\t\t\troom.songs << @song\n\t\t $redis.publish(\"add_song_#{room.id}\", {title: @song.title, added_by: @song.added_by, sc_ident: @song.sc_ident, album_art: @song.album_art}.to_json)\n\t\tend\n render nothing: true\n\tend",
"def add_songs(songs)\n songs.each { |song| add_song(song) }\n end",
"def add_songs(songs)\n songs.each { |song| add_song(song) }\n end",
"def add_songs(songs)\n songs.each { |song| add_song(song) }\n end",
"def generate_playlist\n previous_track_ids = get_playlist_tracks(PLAYLIST_ID).map {|t| t['id']}\n final_track_ids = (previous_track_ids + hot_tracks).uniq # remove duplicates\n\n auth = \"?client_secret=#{CLIENT_SECRET}&client_id=#{CLIENT_ID}&app_version=#{APP_VERSION}\" # app_version taken from network tab, console\n params = {playlist: {tracks: final_track_ids}}\n access_token = get_access_token\n\n # only update playlist if new hot tracks were found\n if previous_track_ids.uniq.sort != final_track_ids.uniq.sort\n Curl.put(BASE_URL_PUT + PLAYLISTS_ENDPOINT + PLAYLIST_ID + auth, params.to_json) do |http|\n http.headers['Origin'] = 'https://soundcloud.com'\n http.headers['Authorization'] = \"OAuth #{access_token}\"\n end\n\n playlist = Playlist.find_or_create_by(soundcloud_id: PLAYLIST_ID)\n playlist.track_ids = final_track_ids\n playlist.save\n end\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n\n end",
"def add_a_song(song)\n @list_of_songs.push(song)\n end",
"def add_song(song)\r\n @songs << song\r\n song.artist = self\r\n end",
"def kind\n :playlist\n end",
"def add_song(song)\n @songs << song #add songs by sheveling song into the @song instance\n song.artist = self #add artists name of the songs\n end",
"def test_playlist\n end",
"def add_song(song)\n @songs.push(song)\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @songs << song\n song.artist = self\n end",
"def add_song(song) ### arg is song instance ###\n\t\tsong.artist = self\n\t\tsong.artist.songs << song\n\tend",
"def add_song(song)\n if(!songs.include?song)\n songs.add(song)\n end\n end",
"def add_song(song)\n song.genre = self unless song.genre\n @songs << song unless @songs.include?(song)\n end",
"def add_song(song)\n #associates a song to the artist's collection\n @songs << song\n song.artist = self\n end",
"def add_song(song)\n @@songs << song\n song.artist = self\n end",
"def store(details)\n track = RSpotify::Track.search(\"#{details[0]} #{details[1]}\", limit: 1).first\n song_details = {\n 'name' => track.name,\n 'id' => track.id,\n 'artist' => track.artists[0].name\n }\n @playlist << song_details\n update_playlist\n end",
"def run_init\n slist = @playlist.data\n\n # Skip the ones already played.\n if (opos = @cursong.position) > 0\n if opos < slist.size\n @playlist.truncate(slist.size - opos)\n @cursong.position = 0\n slist = @playlist.data\n end\n end\n\n # This must run after the player has started\n if slist.size > 0\n add_songs(slist, true)\n end\n @cursong.refresh\n end",
"def add_song(song)\n song.artist= self\n @songs << song\n end",
"def add_song(song)\n self.songs << song\n new_song = Song.new(song)\n new_song.artist = self\n end",
"def add_song(song)\n song.artist = self\n @songs << song\n end",
"def add_song(song)\n song.artist = self\n @songs << song\n end",
"def prepend(opts)\n playlist_control :insert, opts\n end",
"def create\n @playlist = Playlist.new(params[:playlist])\n\n if @playlist.save\n redirect_to \"/setlist/#{@playlist.id}\"\n end\n end",
"def add_song(song)\n @@song_count += 1\n @songs << song\n song.artist = self #self refers to Artist\n\n end",
"def add_song(new_song)\n @songs.include?(new_song) ? (puts \"The song has already been added\") : @songs.push(new_song)\n end",
"def add_song(new_song)\n @songs.include?(new_song) ? (puts \"The song has already been added\") : @songs.push(new_song)\n end",
"def favorite_playlist\n super || create_favorite_playlist\n end",
"def add\n song_query = @prompt.ask('What is the name of the song?')\n tracks = RSpotify::Track.search(song_query, limit: 5)\n cleaned_results = []\n tracks.each { |t| cleaned_results << \"#{t.name} by #{t.artists[0].name}\" }\n system('clear')\n cleaned_results << 'Back'\n selection = @prompt.select('Please select one of the search results:', cleaned_results).split(' by ')\n menu if selection[0] == 'Back'\n store(selection)\n end",
"def add_song\n @song = Song.find_by_id(params[:song_id])\n @mix.add_song(@song)\n redirect_back(fallback_location: @mix)\n end",
"def call\n return unless context.user.auto_sync?\n begin\n playlist = context.spotify_user.create_playlist!(context.backup_playlist_name)\n playlist.add_tracks!(context.discover_weekly_playlist.tracks)\n context.backup_spotify_playlist = playlist\n rescue\n context.fail!(message: \"Couldn't create the playlist on Spotify. Please try again later\")\n end\n end",
"def create\n @user = current_user\n @playlist = Playlist.new(get_params)\n respond_to do |format|\n \n if @playlist.save\n @user.playlists << @playlist\n if @playlist.name.empty?\n @playlist.name=\"playlist\"+@playlist.id.to_s\n @playlist.save\n end\n format.html { redirect_to @playlist, notice: 'Your playlist was successfully created.' }\n format.json { render json: { :status => :created, :message => @playlist}, location: @playlist }\n else\n format.html { render :new }\n format.json { render json: { :status => :unprocessable_entity, :message => @playlist.errors.full_messages } }\n end\n end\n end",
"def update_playlist(p)\n\t\treturn unless create_playlist?\n\t\t\n\t\tbegin\n\t\t\tcase provider\n\t\t\twhen \"facebook\"\n\t\t\t\tupdate_playlist_on_facebook(p)\n\t\t\tend\n\t\trescue Exception => e\n\t\t\tlogger.debug \"error updating playlist on service: #{provider}\"\n\t\t\tcatch_error(p, e)\n\t\tend\n\tend",
"def add_song(song)\n @songs << song\n song.artist = self\nend",
"def do_add(pathname)\n fail CvlcClientError, \"No such file or directory '#{pathname}'\" unless File.exist? \"#{@music_root}/#{pathname}\"\n string = url_encode(pathname.sub(%r{/+$}, ''))\n do_command(\"requests/status.json?command=in_play&input=file://#{@music_root}/#{string}&option=novideo\")\n return currently_playing\n end",
"def add_song(song)\n return if Song.find_by_id(song).nil?\n songs << song\n end",
"def register(song_name)\n prior_play = @current_user.listens.select{|listen| listen.name == song_name}.first\n if prior_play\n @current_listen = prior_play\n @current_listen.plays += 1\n else\n @current_listen = Listen.new\n @current_listen.name = song_name\n @current_listen.plays = 1\n @current_user.listens << @current_listen\n end\n end",
"def do_add\n file_paths = ARGV.dup\n\n file_paths.map! { |path| File.expand_path(path) }\n \n file_paths.each do |path|\n ensure_exists(path)\n end\n\n audiofiles = file_paths.map do |path|\n af = nil # SCOPE\n TagLib::FileRef.open(path) do |ref|\n if ref.null?\n warnx(\"#{path}: not an audio file?\")\n exit 1\n end\n warnx(\"parsing #{path}\")\n tags = ref.tag\n af = AudioFile.new(path, tags.title, tags.artist, tags.album)\n end\n\n af\n end\n\n File.open(@playlist_path, \"w\") { |fd|\n fd.puts(PlaylistWriter.new(audiofiles).to_s)\n }\nend",
"def add_song_request(guest, song)\n found_guest = find_checked_in_guest_by_name(guest.name)\n found_guest.room.playlist << song\n end",
"def play_songs\n MusicImporter.new(path).play_song\n end",
"def shout_playlist\n @clg_name = College.find(params[:id])\n #mount_name = @clg_name.mount_point\n #mount = \"/#{mount_name}.m3u\" # doc[0].split.third unless doc[0].split.third.present? #\"/#{mount_name}.m3u\" # \"/#{object.name.split.join.downcase}.m3u\"\n # s.charset = \"UTF-8\"\n # s.port = 8022\n # s.host = \"localhost\"\n # s.user = \"source\"\n # s.pass = \"bpsi@123\"\n # s.format = Shout::MP3\n #@s.description ='song classic'\n \n # @s.connect\n #puts \"open VLC and open network -> http://#{@s.host}:#{@s.port}\"+\"#{@s.mount}\"\n \n # puts s.description\n # filename = \"#{Rails.root}/public/Playlist/qwerty.m3u\"\n # #ARGV.each do |filename|\n # debugger\n # File.open(filename) do |file|\n # puts \"sending data from #{file}\"\n # m = ShoutMetadata.new\n # m.add 'filename', filename\n # m.add 'title', 'title'\n # @s.metadata = m\n\n # while data = file.read(BLOCKSIZE)\n # @s.send data\n # @s.sync\n # end\n\n # end\n #end\n\n # s.disconnect \n #redirect_to :back\n #s.connect\n render :text => \"Connect\"\n end",
"def touch\n playlist = self.class.first(\n :readonly => false,\n :conditions => {:user_id => user.id, :url_spotify => self.class.url_to_url_spotify(url)})\n return unless playlist\n playlist.updated_at = DateTime.now\n playlist.save\n end",
"def add_song_by_name(song_title) #enter string title\n song = Song.new(song_title) # initialize new song by title\n self.add_song(song)\t# call add_song method to\n\tend",
"def playlist_end playlist\n playlist_print playlist\n end",
"def new_playlist(m={})\n # default selection parameters\n number=60\n max_length=0\n min_rating=0\n max_rating=0\n min_length=0\n # assign if parameters got passed as arguments\n max_length = m[:length] if m.key?(:length)\n number=m[:number] if m.key?(:number)\n # make a semi-randomized list of dances\n dances=make_a_dancelist(number)\n # set up a unique name for playlist generated\n now=Time.now\n nows=now.strftime(\"%y%m%d%H%M%S\")\n name=\"pl_#{nows}\"\n # create the playlist in the database\n playlist=Playlist.new()\n playlist.name=name\n playlist.save\n ordinal=10\n f=File.new(\"#{name}.m3u\", \"w\")\n songs = []\n dances.each do |d|\n # get all the songs for a dance\n la = Song.where(:dance=>d.dance)\n # choose songs shorter than max_length\n if max_length > 0\n lb = la.where{:length < max_length}\n la=lb\n end\n # choose songs with rating higher than min_rating\n if min_rating > 0\n lb = la.where{:rating >= min_rating}\n la=lb\n end\n #get an enumeration by song uid\n lm = la.map(:uid)\n # pick a random song\n idx = (rand() * (lm.length - 1)).round\n # make sure I haven't picked it before\n songs.each do |uid|\n if lm[idx] == uid\n i = idx + 1\n idx = i % lm.length\n end\n end\n song=Song[:uid=>lm[idx]]\n pls=Plsong.new\n pls.order=ordinal\n pls.song_id = song.id\n pls.playlist_id = playlist.id\n pls.save\n ordinal = ordinal + 10\n f.puts song.path\n songs << song\n end\n f.close\n songs \n# create a unique name for the playlist\nend",
"def set_playlist\n @playlist = Playlist.find_by(id:params[:id])\n end",
"def added_songs(playlist)\n valid_songs(changes[\"playlists\"][\"update\"][playlist[\"id\"]][\"song_ids\"])\nend",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end"
] |
[
"0.6616027",
"0.64913815",
"0.64092594",
"0.638075",
"0.6302139",
"0.6292513",
"0.62877065",
"0.6255536",
"0.62553316",
"0.62321717",
"0.6228287",
"0.6226817",
"0.6194212",
"0.6181943",
"0.61334336",
"0.6117756",
"0.6101854",
"0.6098525",
"0.6084723",
"0.60626733",
"0.6057634",
"0.6057634",
"0.6057634",
"0.6057634",
"0.6057634",
"0.6057634",
"0.60218",
"0.6019665",
"0.60193884",
"0.60065717",
"0.59894425",
"0.5981017",
"0.5965209",
"0.59429884",
"0.5936829",
"0.5919527",
"0.58977014",
"0.58807373",
"0.5878581",
"0.5865199",
"0.5865199",
"0.5865199",
"0.58595663",
"0.5859366",
"0.5845645",
"0.5844162",
"0.58380157",
"0.5826917",
"0.5823965",
"0.5823546",
"0.5794227",
"0.5794227",
"0.5794227",
"0.5794227",
"0.5794227",
"0.5794227",
"0.5794227",
"0.5794227",
"0.5794227",
"0.5794227",
"0.5794227",
"0.5785506",
"0.5785253",
"0.57848555",
"0.5776508",
"0.57713884",
"0.5756767",
"0.5753928",
"0.57469684",
"0.5744071",
"0.5741212",
"0.5741212",
"0.5722505",
"0.5699641",
"0.56937706",
"0.5692782",
"0.5692782",
"0.56918633",
"0.5689236",
"0.566382",
"0.5660948",
"0.5655071",
"0.56546384",
"0.565166",
"0.5645807",
"0.5645633",
"0.5629316",
"0.5625021",
"0.5610705",
"0.56086665",
"0.56036085",
"0.5594937",
"0.5588878",
"0.55888647",
"0.5587476",
"0.55783904",
"0.5577835",
"0.55719537",
"0.55719537",
"0.55719537"
] |
0.67087215
|
0
|
add selected videos to playlist
|
def add_multiple_screeners
@notice = ""
@screener_playlist = ScreenerPlaylist.find(params[:playlist_id])
screener_ids = params[:screener_ids]
screener_ids.each do |screener_id|
@screener_playlist_item_position = ScreenerPlaylistItem.where("screener_playlist_id=?", params[:playlist_id])
.order("position ASC")
.find(:last)
@screener_playlist_item_position = @screener_playlist_item_position.nil? ? 1 : @screener_playlist_item_position.position + 1
@screener_playlist_item = ScreenerPlaylistItem.new(screener_playlist_id: params[:playlist_id],
screener_id: screener_id,
position: @screener_playlist_item_position)
@screener_to_add = Screener.find(screener_id)
if @screener_playlist_item.save
flash[:notice] = 'Screeners were successfully added.'
session[:screeners_search] = collection_to_id_array(@screener_playlist.screeners)
end
end # loop through video ids
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def add_multiple_videos\n\n @notice = \"\"\n @video_playlist = VideoPlaylist.find(params[:playlist_id])\n video_ids = params[:video_ids]\n\n video_ids.each do |video_id|\n @video_playlist_item_position = VideoPlaylistItem.where(\"video_playlist_id=?\", params[:playlist_id])\n .order(\"position ASC\")\n .find(:last)\n @video_playlist_item_position = @video_playlist_item_position.nil? ? 1 : @video_playlist_item_position.position + 1\n @video_playlist_item = VideoPlaylistItem.new(video_playlist_id: params[:playlist_id],\n video_id: video_id,\n position: @video_playlist_item_position)\n\n @video_to_add = Video.find(video_id)\n if @video_playlist_item.save\n flash[:notice] = 'Videos were successfully added.'\n session[:videos_search] = collection_to_id_array(@video_playlist.videos)\n end\n end # loop through video ids\n\n end",
"def add_videos(gallery_name, video_url_list = [\"http://www.youtube.com/watch?v=Jr-ubPWN7n4\", \"http://www.youtube.com/watch?v=K-KkSiIjlm0\"], _browser = @browser)\n Log.logger.info(\"Adding New Videos into the Gallery.\")\n add_media_action(gallery_name, video_url_list, _browser)\n end",
"def add_video\n\n @video_playlist = VideoPlaylist.find(params[:id])\n @video_playlist_item_position = VideoPlaylistItem.where(\"video_playlist_id=?\", params[:id])\n .order(\"position ASC\")\n .find(:last)\n @video_playlist_item_position = @video_playlist_item_position.nil? ? 1 : @video_playlist_item_position.position + 1\n @video_playlist_item = VideoPlaylistItem.new(video_playlist_id: params[:id],\n video_id: params[:video_id],\n position: @video_playlist_item_position)\n\n @notice=\"\"\n\n @video_to_add = Video.find(params[:video_id])\n\n if @video_playlist_item.save\n flash[:notice] = 'Video was successfully added.'\n session[:videos_search] = collection_to_id_array(@video_playlist.videos)\n end\n end",
"def add_video_to_my_queues(video)\n visit home_path\n #find(\"a[href='/videos/#{video.to_param}']\").click\n find(\"a[href='/videos/#{video.token}']\").click\n click_link \"+ My Queue\"\n end",
"def append(opts)\n playlist_control :add, opts\n end",
"def add_videos_to_album album_id, videos\n body = {}\n body['videos'] = videos if videos.is_a? String\n body['videos'] = videos.join(',') if videos.is_a? Array\n put(\"/albums/#{album_id}/videos\", body:body, code: 201)\n end",
"def create_videos\n end",
"def add_multiple_movies\n \n @notice = \"\"\n @movie_playlist = MoviePlaylist.find(params[:playlist_id])\n movie_ids = params[:movie_ids]\n \n movie_ids.each do |movie_id|\n @movie_playlist_item = MoviePlaylistItem.new(:movie_playlist_id => params[:playlist_id], :movie_id => movie_id, :position => @movie_playlist.movie_playlist_items.count + 1)\n \n if @movie_playlist_item.save\n flash[:notice] = 'Movies were successfully added.'\n @notice = 'Movies were successfully added.'\n session[:movies_search] = collection_to_id_array(@movie_playlist.movies)\n end\n end # loop through movie ids\n \n end",
"def call\n video = search_youtube\n if video.present?\n context.playlist.add_video!(\n title: video.title,\n url: \"https://www.youtube.com/watch?v=#{video.id}\",\n user: context.user\n )\n context.dj.new_video_added!\n context.message = \"Success! #{video.title} was added to the playlist.\"\n else\n context.errors = \"Sorry but couldn't find any vides for #{query}.\"\n context.fail!\n end\n end",
"def playlist_end playlist\n end",
"def add_video(video)\n @videos << video\n return true\n end",
"def set_videolist\n @videolist = Videolist.find(params[:id])\n end",
"def selected_playlist(value)\n @ole.SelectedPlaylist = value\n nil\n end",
"def video_list\n self.video_list = videos.map { |video| video[\"title\"] }\n end",
"def add_multiple_movies\n\n @notice = \"\"\n @movie_playlist = MoviePlaylist.find(params[:playlist_id])\n movie_ids = params[:movie_ids]\n\n movie_ids.each do |movie_id|\n @movie_playlist_item_position = MoviePlaylistItem.where(\"movie_playlist_id=?\", params[:playlist_id])\n .order(\"position ASC\")\n .find(:last)\n @movie_playlist_item_position = @movie_playlist_item_position.nil? ? 1 : @movie_playlist_item_position.position + 1\n @movie_playlist_item = MoviePlaylistItem.new(movie_playlist_id: params[:playlist_id],\n movie_id: movie_id,\n position: @movie_playlist_item_position)\n\n if @movie_playlist_item.save\n flash[:notice] = 'Movies were successfully added.'\n @notice = 'Movies were successfully added.'\n session[:movies_search] = collection_to_id_array(@movie_playlist.movies)\n end\n end # loop through movie ids\n\n end",
"def videos_for(items, key, options)\n items.body['items'].map{|item| item['id'] = item[key]['videoId']}\n\n if options[:parts] == %i(id)\n items\n else\n options[:ids] = items.body['items'].map{|item| item['id']}\n options[:offset] = nil\n fetch('/youtube/v3/videos', resource_params(options)).tap do |response|\n response.body['nextPageToken'] = items.body['nextPageToken']\n end\n end\n end",
"def videos\n @hot_video_mapper.build_video_items(@list_data['items'])\n end",
"def add_video(tag)\n\n @driver.find_element(:link, 'Add Video').click\n\n wait = Selenium::WebDriver::Wait.new(:timeout => 30) # seconds\n wait.until { @driver.find_element(:link_text, \"Save Video\") }\n\n # Type in URL of video into\n @driver.find_element(:id, 'videoUrlField').send_keys(tag)\n @driver.find_element(:link_text, \"Save Video\").click\n\n # Wait while video is processed\n wait = Selenium::WebDriver::Wait.new(:timeout => 30) # seconds\n wait.until { @driver.find_element(:link_text, \"Edit Video\") }\n end",
"def add_video(aTitle)\n # Simplification: no check for title collision\n catalogue << Video.new(aTitle, :available)\n save_catalogue\n end",
"def videos_test\n end",
"def add_movie\n\n @movie_playlist = MoviePlaylist.find(params[:id])\n @movie_playlist_item = MoviePlaylistItem.new(:movie_playlist_id => params[:id], :movie_id => params[:movie_id], :position => @movie_playlist.movie_playlist_items.count + 1)\n @notice=\"\"\n @movie_to_add = Movie.find(params[:movie_id])\n if @movie_playlist_item.save\n flash[:notice] = 'Movie was successfully added.'\n session[:movies_search] = collection_to_id_array(@movie_playlist.movies)\n end\n end",
"def add_video_to_queue(video)\n visit home_path\n click_on_video_on_home_page(video) # This method is in macros.rb\n click_link \"+ My Queue\"\n end",
"def add (context = :playlist, *paths)\n\t\tpaths.flatten.compact.uniq.each {|path|\n\t\t\tsend \"add -#{context.to_s[0]} #{File.realpath(File.expand_path(path))}\"\n\t\t\tcheck_for_error\n\t\t}\n\n\t\tself\n\tend",
"def add_selected_song_to_liked_songs\n song_instance = Song.all.find do |song|\n song.title == @selected_song\n end \n\n Playlist.create(user: @user, song_id: song_instance.id)\n puts \"Great choice!, We've added '#{@selected_song}' to your 'Liked' songs.\"\n \n question_1\n end",
"def populate\n @video = Video.find(params[:video_id])\n render :nothing => true and return if @collection.videos.include? @video\n @collection << @video\n\n respond_to do |format|\n format.html { redirect_to :back, :notice => \"Video added to your reel.\" }\n format.js\n end\n end",
"def new_video_added!\n start! if waiting?\n end",
"def create\n # @video = Video.new(params[:video])\n \n # @video = current_user.videos.new(params[:video])\n \n @video = Video.new\n @video.user_id = current_user.id\n @video.archive_id = params[:video][:archive_id]\n @video.question_id = params[:video][:question_id]\n \n current_user.videos << @video\n\n respond_to do |format|\n if @video.save\n # format.html { redirect_to @video, notice: 'Video was successfully created.' }\n format.json { render json: @video, status: :created, location: @video }\n else\n # format.html 3{ render action: \"new\" }\n format.json { render json: @video.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_multiple_masters\n \n @notice = \"\"\n @video_master_playlist = VideoMasterPlaylist.find(params[:playlist_id])\n master_ids = params[:master_ids]\n \n master_ids.each do |master_id|\n @video_master_playlist_item = VideoMasterPlaylistItem.new(:video_master_playlist_id => params[:playlist_id], :master_id => master_id, :position => @video_master_playlist.video_master_playlist_items.count + 1)\n\n @master_to_add = Master.find(master_id)\n if @video_master_playlist_item.save\n flash[:notice] = 'Masters were successfully added.'\n session[:masters_search] = collection_to_id_array(@video_master_playlist.masters)\n end\n end # loop through video ids\n \n end",
"def move\n\t\tplayitems = params[:items]\n\t\t@playlist = Playlist.find(params[:playlist])\n\t\t\n\t\t\n\t\t#\n\t\t# Good or bad? this can't fail :) (technically)\n\t\t#\n\t\tPlaylistMedia.where('id IN (?)', playitems).update_all(:playlist_id => @playlist.id, :published => false)\n\t\n\t\t\n\t\trespond_with(@playlist) do |format|\n\t\t\tformat.js { render :action => 'update_playlist', :layout => false }\n\t\tend\n\tend",
"def index \n @pos = 0\n if params[:name] != nil && (params[:name][0..3] == \"http\" || params[:name][0..2] == \"www\")\n client = YouTubeIt::Client.new(:dev_key => \"AI39si4IGrrB9qyNNgKqtW7YKqTSxpG54pBcyVZ8wQANOPcKeDVgGDorcP9DkrxFcPsI_gW3pJ0T2oAFB3stXtaWG_hbAsdNfA\")\n playlist_id = params[:name].split('=').last\n new_playlist = Playlist.new\n new_playlist.update_attributes(:name => client.playlist(playlist_id).title, :position => 1)\n new_playlist.save\n @isprelist = true\n @agent ||= init_agent\n page = @agent.get(params[:name])\n len = page.at(\"#watch7-playlist-length\").text.to_i rescue nil\n if len == nil\n len = page.at(\".first .stat-value\").text.to_i\n end\n startindex = 1\n maxresults = 0\n while len - startindex > 0\n if len - startindex > 50\n maxresults = 50\n else\n maxresults = len - maxresults\n end\n playlist_vids = client.playlist(playlist_id, {'start-index' => startindex, 'max-results' => maxresults}).videos\n for vid in playlist_vids\n new_vid = new_playlist.videos.build\n title = vid.title\n norm_url = \"www.youtube.com/watch?v=\" + vid.media_content[0].url.split('?')[0].split('/').last\n url = vid.media_content[0].url rescue nil\n thumb_url = vid.thumbnails[0].url\n width = 560.to_s\n height = 315.to_s\n embed = '<iframe width=' + width + ' height=' + height + ' src=' + url + ' frameborder=\"0\" allowfullscreen></iframe>'\n new_vid.copy_vids(title, norm_url, thumb_url, \"Youtube\", embed)\n startindex += 1\n end\n end\n @playlists = new_playlist\n else\n current_user.update_attribute(:last_psearch, params[:name])\n @isprelist = false\n @playlists = Playlist.order(:name).where(\"name like ?\", \"%#{current_user.last_psearch}%\")\n @playlists = @playlists.order(\"cached_votes_up DESC\")\n @playlists = @playlists.where(\"privacy = 'Public'\")\n @playlists = @playlists.paginate(:page => params[:page], :per_page => 2)\n end\n respond_to do |format|\n format.html\n format.js\n end\n end",
"def add_video\n @new_video = Video.new(params[:video])\n @new_video.save\n @video = Video.find_all_by_appliance_id_and_brand_id_and_appliance_problem_id(params[:video][:appliance_id], params[:video][:brand_id], params[:video][:appliance_problem_id])\n render(:partial => 'video', :collection => @video)\n end",
"def video(filename, opts = {})\n n = input(filename, opts)\n @videos << n\n n\n end",
"def show\n @videos = @video.responses\n @videos.unshift @video\n end",
"def add_to_playlist(media)\n connection.write(\"enqueue #{media(media)}\")\n end",
"def copy\n\t\tplayitems = PlaylistMedia.find(params[:items])\n\t\t@playlist = Playlist.find(params[:playlist])\n\t\t\n\t\tPlaylistMedia.transaction do\n\t\t\tplayitems.each do |item|\n\t\t\t\tPlaylistMedia.create(item.attributes.merge({:playlist_id => @playlist.id, :id => nil, :published => false}))\n\t\t\tend\n\t\tend\n\t\t\n\t\trespond_with(@playlist) do |format|\n\t\t\tformat.js { render :action => 'update_playlist', :layout => false }\n\t\tend\n\tend",
"def playlist\n connection.write(\"playlist\")\n end",
"def add_songs tracklist, playlist_object\n playlist_object.add_tracks!(tracklist)\n end",
"def add_to_playlist(media)\n connection.write(\"enqueue #{media_arg(media)}\")\n end",
"def show\n @comment = Comment.new\n @bulb = Bulb.new\n @tags = @video.tags.split(\",\")\n @video.increment!(:plays)\n @video.updated_at = DateTime.now\n @video.save!\n @fullscreen = true\n @items = Item.where(video_id: @video.id)\n @playlist_ids = []\n @items.each do |item|\n @playlist_ids << item.playlist\n end\n @playlist_ids.uniq!\n @playlists = Playlist.where(id: @playlist_ids.map(&:id))\n end",
"def add_movie\n\n @movie_playlist = MoviePlaylist.find(params[:id])\n\n @movie_playlist_item_position = MoviePlaylistItem.where(\"movie_playlist_id=?\", params[:id])\n .order(\"position ASC\")\n .find(:last)\n @movie_playlist_item_position = @movie_playlist_item_position.nil? ? 1 : @movie_playlist_item_position.position + 1\n\n @movie_playlist_item = MoviePlaylistItem.new(movie_playlist_id: params[:id],\n movie_id: params[:movie_id],\n position: @movie_playlist_item_position)\n @notice=\"\"\n @movie_to_add = Movie.find(params[:movie_id])\n if @movie_playlist_item.save\n flash[:notice] = 'Movie was successfully added.'\n session[:movies_search] = collection_to_id_array(@movie_playlist.movies)\n end\n end",
"def call\n if url.valid? and video.present?\n context.playlist.add_video!(\n title: video.title,\n url: url.to_s,\n user: context.user\n )\n context.dj.new_video_added!\n context.message = \"Success! Your video was added to the playlist.\"\n else\n context.fail!\n context.errors = \"That doesn't look like a valid youtube url. \"\n end\n end",
"def queue_video(file)\n if video?(file) or contains_any?(file, :avi, :mpg, :mkv, :rm, :mp4)\n puts ''\n puts file\n local = \"/Volumes/Samba/clamps/\"\n dir = prompt_for_path(local)\n \n remote_path = \"#{ REMOTE_VIDEO_PATH }#{ dir[local.length, dir.length] }#{ Pathname.new(file).basename }\"\n QUEUE << [ file, remote_path ]\n end\nend",
"def queue_video!(video)\n queue_items.create(video: video, \n position: new_queue_item_position) unless queued_video?(video)\n end",
"def add_to_queue(playlist)\n @queue << playlist\n if @current_playlist.nil? \n @current_playlist = @queue.shift\n play @current_playlist\n end\n end",
"def add_song\n \t# add this song to the users personal list (history)\n new_song = Song.create(title: params[:title], video_id: params[:video_id], status: \"added to MusiQ!\")\n current_user.songs << new_song\n\n # add this song to the player queue (tracks)\n Track.create(title: params[:title], video_id: params[:video_id], user_id: current_user.id, status: 'waiting')\n redirect_to root_url\n end",
"def create\n\t\tmedia_ids = params[:medias]\n\t\t@playlist = Playlist.find(params[:playlist_id])\n\t\tmedia_ids = GroupMedia.where('media_id IN (?) AND group_id = ?', media_ids, current_group.id).pluck(:id)\n\t\t\n\t\tPlaylistMedia.transaction do\n\t\t\tmedia_ids.each do |media_id|\n\t\t\t\tplayitem = PlaylistMedia.new(:playlist_id => @playlist.id, :group_media_id => media_id)\n\t\t\t\traise \"Save error\" unless playitem.save\n\t\t\tend\n\t\tend\n\t\t\n\t\trespond_with(@playlist) do |format|\n\t\t\tformat.js { render :action => 'update_playlist', :layout => false }\n\t\tend\n\tend",
"def add_video_to_folder folder_id, video_id\n put(\"/projects/#{folder_id}/videos/#{video_id}\", code: 204)\n end",
"def AddToPlayList(media, playlist=nil, mask=nil, recursive=true)\n if(recursive == true)\n recursive = 1\n else\n recursive = 0\n end\n success?(parse(cmd(with_args(media, playlist, mask, recursive))))\n end",
"def mergeVideos()\n pathToIntermediates=\"#{$PATHTOGENERATEINTERMEDIATES}/#{@meetingData.meetingId}\"\n vidList=\"#{pathToIntermediates}/vidList.txt\"\n # Create a txt file with the lists of all videos to concatenate\n system \"echo >#{vidList}\"\n (0...@objects.length).each do |e|\n system \"echo file \\'#{pathToIntermediates}/vid-#{e}.mp4\\' >> #{vidList}\" \n end\n # Concatenate videos from the txt file\n system \"ffmpeg -f concat -safe 0 -i #{vidList} -c copy #{pathToIntermediates}/output.mp4 -loglevel quiet\"\n end",
"def get_playlist_vids(playlist)\n Log.log.debug \"Returning playlist vids\"\n vids = Array.new\n playlist.playlist_items.each {|item| vids << item.video_id}\n return vids\nend",
"def current_playlist\n super || create_current_playlist\n end",
"def set_Playlist(value)\n set_input(\"Playlist\", value)\n end",
"def put_video(*video_args, &block)\n args = parse_media_args(video_args, \"videos\")\n args.last[:video] = true\n put_connections(*args, &block)\n end",
"def videolist_params\n params.require(:videolist).permit(:videoid, :videoURL, :flag, :title, :category, :author, :description, :uptime, :tag)\n end",
"def add_subtitles(movie)\n video_file_res = movie.project.final + \"/video.avi\"\n video_file = movie.project.final + \"/videotrack.avi\"\n cmd = @settings['subtitles'].dup\n cmd.sub!('<source>', video_file)\n cmd.sub!('<target>', video_file_res)\n cmd.sub!('<subtitles>', movie.subtitles)\n puts \"Adding subtitles\"\n puts cmd\n system(cmd)\n return video_file_res\n end",
"def do_add\n file_paths = ARGV.dup\n\n file_paths.map! { |path| File.expand_path(path) }\n \n file_paths.each do |path|\n ensure_exists(path)\n end\n\n audiofiles = file_paths.map do |path|\n af = nil # SCOPE\n TagLib::FileRef.open(path) do |ref|\n if ref.null?\n warnx(\"#{path}: not an audio file?\")\n exit 1\n end\n warnx(\"parsing #{path}\")\n tags = ref.tag\n af = AudioFile.new(path, tags.title, tags.artist, tags.album)\n end\n\n af\n end\n\n File.open(@playlist_path, \"w\") { |fd|\n fd.puts(PlaylistWriter.new(audiofiles).to_s)\n }\nend",
"def add_video_master\n\n @video_master_playlist = VideoMasterPlaylist.find(params[:id])\n @video_master_playlist_item_position = VideoMasterPlaylistItem.where(\"video_master_playlist_id=?\", params[:id])\n .order(\"position ASC\")\n .find(:last)\n @video_master_playlist_item_position = @video_master_playlist_item_position.nil? ? 1 : @video_master_playlist_item_position.position + 1\n @video_master_playlist_item = VideoMasterPlaylistItem.new(video_master_playlist_id: params[:id],\n master_id: params[:master_id],\n position: @video_master_playlist_item_position)\n\n @notice=\"\"\n\n @master_to_add = Master.find(params[:master_id])\n\n if @video_master_playlist_item.save\n flash[:notice] = 'Master was successfully added.'\n session[:masters_search] = collection_to_id_array(@video_master_playlist.masters)\n end\n end",
"def playlist_end playlist\n playlist_print playlist\n end",
"def add_video\n @videoset = @user_profile.videosets.find_by_permalink(params[:id])\n if request.post?\n if !params[:video][:videofile].blank?\n @video = Video.new(params[:video])\n @video.videoset_id = @videoset.id\n @video.created_on= Time.now\n @video.updated_on= Time.now \n if @video.save\n return_val = grab_screenshot_from_video(@video.id)\n if return_val == \"Unknown file\"\n flash[:notice] = \"The video file you have uploaded is corrupted or it doesn't support video format. Please upload a correct video file\" \n redirect_to :action => 'add_video_to_set', :id => @videoset.permalink and return \n end\n linkset = Linkset.add_linkset(@videoset.id,'videoset',params[:linkset]) \n flash[:notice] = \"Video was successfully added to videoset - ' #{@videoset.title}'\" \n redirect_to :action => 'add_video_to_set', :id => @videoset.permalink and return \n else\n flash[:notice] = \"Unable to add video to this videoset\" \n render :action => 'add_video_to_set'and return \n end \n else\n linkset = Linkset.add_linkset(@videoset.id,'videoset',params[:linkset]) \n flash[:notice] = \"Link set was successfully updated.\" \n redirect_to :action => 'add_video_to_set', :id => @videoset.permalink and return \n end \n else\n flash[:notice] = \"Please select a videoset\"\n redirect_to :action => 'index' and return \n end \n #~ rescue\n #~ flash[:notice] = \"Unable to add video to this videoset\" \n #~ render :template => 'shared/error'and return \nend",
"def upload_video(new_attributes={})\n BlipTV::ApiSpec.check_attributes('videos.upload', new_attributes)\n\n new_attributes = {\n :post => \"1\",\n :item_type => \"file\",\n :skin => \"xmlhttprequest\",\n :file_role => \"Web\"\n }.merge(new_attributes) # blip.tv requires the \"post\" param to be set to 1\n\n request = BlipTV::Request.new(:post, 'videos.upload')\n request.run do |p|\n for param, value in new_attributes\n p.send(\"#{param}=\", value)\n end\n end\n\n BlipTV::Video.new(request.response['post_url'].to_s)\n end",
"def playlist\n split_and_hash(send_request('playlistinfo'))\n end",
"def added_songs(playlist)\n valid_songs(changes[\"playlists\"][\"update\"][playlist[\"id\"]][\"song_ids\"])\nend",
"def videos options={}\n response = client.get(\"/#{id}/videos\", options)\n end",
"def set_playlist\n @playlist = Playlist.find(params[:playlist_id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def add_multiple_masters\n\n @notice = \"\"\n @video_master_playlist = VideoMasterPlaylist.find(params[:playlist_id])\n master_ids = params[:master_ids]\n\n master_ids.each do |master_id|\n @video_master_playlist_item_position = VideoMasterPlaylistItem.where(\"video_master_playlist_id=?\", params[:playlist_id])\n .order(\"position ASC\")\n .find(:last)\n @video_master_playlist_item_position = @video_master_playlist_item_position.nil? ? 1 : @video_master_playlist_item_position.position + 1\n @video_master_playlist_item = VideoMasterPlaylistItem.new(video_master_playlist_id: params[:playlist_id],\n master_id: master_id,\n position: @video_master_playlist_item_position)\n\n @master_to_add = Master.find(master_id)\n if @video_master_playlist_item.save\n flash[:notice] = 'Masters were successfully added.'\n session[:masters_search] = collection_to_id_array(@video_master_playlist.masters)\n end\n end # loop through video ids\n\n end",
"def kind\n :playlist\n end",
"def generate_video_poll\n # randomly pull out 6 videos\n video_poll = VideoPoll.new(\n room_id: id\n )\n puts ' '\n puts 'chosen'\n unless unplayed_videos.length >= 6\n update(last_playlist_completion_time: Time.now)\n reload\n end\n unchosen_videos = unplayed_videos\n 6.times.each do\n video_index = rand(unchosen_videos.length)\n video = unchosen_videos[video_index]\n # byebug if !video\n unchosen_videos.delete_at(video_index)\n c_video = CandidateVideo.create(\n video: video,\n video_poll: video_poll,\n )\n c_video.reload\n # if !c_video\n # byebug\n # end\n end\n video_poll.save\n video_poll.reload\n video_poll\n end",
"def update_playlist(id, new_name = nil, new_description = nil, new_public = nil)\n update_playlists [{id: id, name: new_name, description: new_description, public: new_public}][0]\n end",
"def add_video_to_album album_id, video_id\n put(\"/albums/#{album_id}/videos/#{video_id}\", code: 204)\n end",
"def add_track(new_song)\n if AVAILABLE_SONGS.include?(new_song)\n @playlist << new_song\n else\n return false\n end\n end",
"def set_playlist\n @playlist = Playlist.find_by(id:params[:id])\n end",
"def create\n @video = Video.new(video_params)\n @video.added_by=current_user.id\n respond_to do |format|\n if @video.save\n @video.add_labels(params[:Label])\n format.html { redirect_to media_videos_path}\n format.json { render :show, status: :created, location: [:media, @video] }\n format.js {}\n else\n format.html { render :new }\n format.json { render json: [:media, @video.errors], status: :unprocessable_entity }\n end\n end\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def video_params\n params.require(:video).permit(:url, :item_id)\n end",
"def video_params\n params.require(:video).permit(:url, :item_id)\n end",
"def add_song_to_playlist(song)\n if @playlist.include? song\n return #exit out of function if already exits\n end\n @playlist << song #else add song to playlist array\n end",
"def videos_params\n params.require(:video).permit(:title, :author, :year, :duration, :video_url, :image_url, :is_winner, :is_entrant, :is_other, :id_for_app)\n end",
"def add_master\n\n @video_master_playlist = VideoMasterPlaylist.find(params[:id])\n @video_master_playlist_item = VideoMasterPlaylistItem.new(:video_master_playlist_id => params[:id], :master_id => params[:master_id], :position => @video_master_playlist.video_master_playlist_items.count + 1)\n\n @notice=\"\"\n\n @master_to_add = Master.find(params[:master_id])\n\n if @video_master_playlist_item.save\n flash[:notice] = 'Master was successfully added.'\n session[:masters_search] = collection_to_id_array(@video_master_playlist.masters)\n end\n end",
"def set_playlist_and_track\n @playlist = Playlist.find(params[:playlist_id])\n @track = @playlist.playlist_tracks.find(params[:track_id])\n end",
"def index\n @videolists = Videolist.all\n end",
"def set_youtube_playlist\n @youtube_playlist = YoutubePlaylist.find(params[:id])\n end",
"def playlist_params\n params.require(:playlist).permit(:title, :description, :published_state, :user_id, tag_list: [], cover_attributes: %i[id image])\n end",
"def set_playlist\n @playlist = Playlist.find params[:id]\n end",
"def index\n @lecture = Tutorial.find(params[:lecture_id])\n @videotuts = @lecture.videos.order(:id)\n \n \n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def set_playlist\n @playlist = Playlist.find(params[:id])\n end",
"def add_to_queue(video)\n member = self.queue_members.build video: video,\n list_order: self.next_queue_order\n\n member.save ? member : false\n end",
"def valid_videos\n self.videos.select{ |video|\n video.exist? && video.embed? && video.auto_play?\n }\n end",
"def playlist_params\n params.require(:playlist).permit(:name, :ajax)\n end"
] |
[
"0.7316284",
"0.72339803",
"0.68312114",
"0.6595592",
"0.6514733",
"0.6476899",
"0.6388595",
"0.63495183",
"0.6311904",
"0.6173108",
"0.614058",
"0.6132977",
"0.6110577",
"0.61001635",
"0.60890406",
"0.6058278",
"0.60539895",
"0.6022344",
"0.6021603",
"0.5972253",
"0.59683645",
"0.5963987",
"0.59551543",
"0.59524786",
"0.5933667",
"0.59082085",
"0.58845705",
"0.58758676",
"0.58562374",
"0.585402",
"0.5843775",
"0.5827198",
"0.58253855",
"0.5821829",
"0.5815308",
"0.5811892",
"0.5807278",
"0.5794782",
"0.57926923",
"0.5790247",
"0.5755277",
"0.57390666",
"0.5721922",
"0.57204676",
"0.57100976",
"0.5670922",
"0.5666677",
"0.5662186",
"0.56547576",
"0.5638983",
"0.5635651",
"0.5613114",
"0.5610825",
"0.56101525",
"0.5597511",
"0.55904084",
"0.5585743",
"0.5583331",
"0.5582511",
"0.55645484",
"0.5535921",
"0.5534074",
"0.552487",
"0.5524575",
"0.5524455",
"0.5524455",
"0.5524455",
"0.55240023",
"0.5515593",
"0.55140364",
"0.55117947",
"0.5511407",
"0.5505284",
"0.54990536",
"0.5487103",
"0.54854393",
"0.5482872",
"0.5482872",
"0.54636914",
"0.54634184",
"0.5451731",
"0.5446111",
"0.54407865",
"0.54384685",
"0.54360574",
"0.5433044",
"0.54278976",
"0.5425302",
"0.5425302",
"0.5425302",
"0.5425302",
"0.5425302",
"0.5425302",
"0.5425302",
"0.5425302",
"0.5425302",
"0.5425302",
"0.542223",
"0.54118484",
"0.54084194"
] |
0.5472455
|
78
|
PATCH/PUT /extractions_extraction_forms_projects_sections_type1/1 PATCH/PUT /extractions_extraction_forms_projects_sections_type1/1.json
|
def update
# A bit of security here to ensure we get values we expected:
# - 'false'
# - 'citations'
# - 'project'
propagation_scope = { 'false' => false, 'citations' => :citations,
'project' => :project }[extractions_extraction_forms_projects_sections_type1_params.dig(
:should, :propagate
)]
# If we want to propagate then do it now.
if propagation_scope
@extractions_extraction_forms_projects_sections_type1.propagate_type1_change(propagation_scope,
extractions_extraction_forms_projects_sections_type1_params)
end
respond_to do |format|
if @extractions_extraction_forms_projects_sections_type1.update(extractions_extraction_forms_projects_sections_type1_params)
format.html do
redirect_to work_extraction_path(@extractions_extraction_forms_projects_sections_type1.extraction,
'panel-tab': @extractions_extraction_forms_projects_sections_type1
.extractions_extraction_forms_projects_section
.extraction_forms_projects_section.id),
notice: t('success')
end
format.json { render json: {} }
format.js {}
else
format.html do
flash[:alert] = @extractions_extraction_forms_projects_sections_type1.errors.messages.values.dig(0, 0)
render :edit
end
format.json do
render json: @extractions_extraction_forms_projects_sections_type1.errors, status: :unprocessable_entity
end
format.js {}
end
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_extractions_extraction_forms_projects_sections_type1\n @extractions_extraction_forms_projects_sections_type1 = ExtractionsExtractionFormsProjectsSectionsType1.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @extractions_extraction_forms_projects_sections_type1.update(extractions_extraction_forms_projects_sections_type1_params)\n format.html { redirect_to work_extraction_path(@extractions_extraction_forms_projects_sections_type1\n .extractions_extraction_forms_projects_section\n .extraction,\n anchor: \"panel-tab-#{ @extractions_extraction_forms_projects_sections_type1\n .extractions_extraction_forms_projects_section.id }\"),\n notice: t('success') }\n format.json { head :no_content }\n else\n format.html { render :edit }\n format.json { render json: @extractions_extraction_forms_projects_sections_type1.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_extractions_extraction_forms_projects_sections_type1\n @extractions_extraction_forms_projects_sections_type1 = ExtractionsExtractionFormsProjectsSectionsType1.find(params[:id])\n authorize(@extractions_extraction_forms_projects_sections_type1)\n end",
"def update\n authorize(@extractions_extraction_forms_projects_section)\n respond_to do |format|\n if @extractions_extraction_forms_projects_section.update(extractions_extraction_forms_projects_section_params)\n format.html do\n if params[:extractions_extraction_forms_projects_section].has_key? :extraction_ids\n redirect_to consolidate_project_extractions_path(@extractions_extraction_forms_projects_section.project,\n extraction_ids: params[:extractions_extraction_forms_projects_section][:extraction_ids],\n 'panel-tab': @extractions_extraction_forms_projects_section.extraction_forms_projects_section.id.to_s),\n notice: t('success')\n else\n redirect_to work_extraction_path(\n @extractions_extraction_forms_projects_section.extraction,\n \"panel-tab\": @extractions_extraction_forms_projects_section.extraction_forms_projects_section.id.to_s\n ),\n notice: t('success')\n end\n end\n format.json do\n type1_params = extractions_extraction_forms_projects_section_params[:extractions_extraction_forms_projects_sections_type1s_attributes]\n type1_params = type1_params['0']['type1_attributes']\n type1 = Type1.find_by(name: type1_params['name'], description: type1_params['description'])\n eefpst1 = ExtractionsExtractionFormsProjectsSectionsType1\n .find_by(\n extractions_extraction_forms_projects_section: @extractions_extraction_forms_projects_section,\n type1:\n )\n render json: { extractions_extraction_forms_projects_sections_type1_id: eefpst1.id }\n end\n format.js do\n if params[:extractions_extraction_forms_projects_section][:action] == 'work'\n @consolidated_extraction = @extractions_extraction_forms_projects_section.extraction\n render '/extractions_extraction_forms_projects_sections/work_update'\n else\n @action = params[:extractions_extraction_forms_projects_section][:action]\n @extraction = @extractions_extraction_forms_projects_section.extraction\n @linked_type2_sections = @extractions_extraction_forms_projects_section.link_to_type2s\n @results_eefps = @extraction.find_eefps_by_section_type('Results')\n end\n end\n else\n format.html do\n redirect_to work_extraction_path(\n @extractions_extraction_forms_projects_section.extraction,\n \"panel-tab\": @extractions_extraction_forms_projects_section.extraction_forms_projects_section.id.to_s\n ),\n alert: t('failure')\n end\n format.json do\n render json: @extractions_extraction_forms_projects_section.errors, status: :unprocessable_entity\n end\n format.js do\n end\n end\n end\n end",
"def extractions_extraction_forms_projects_sections_type1_params\n params.require(:extractions_extraction_forms_projects_sections_type1)\n .permit(:type1_type_id, :extractions_extraction_forms_projects_section_id, :type1_id, :name, :description, :units, :notes)\n end",
"def set_extractions_extraction_forms_projects_section\n @extractions_extraction_forms_projects_section = ExtractionsExtractionFormsProjectsSection.find(params[:id])\n end",
"def extractions_extraction_forms_projects_section_params\n params.require(:extractions_extraction_forms_projects_section)\n .permit(:extraction_id,\n :extraction_forms_projects_section_id,\n type1s_attributes: [:id, :name, :description])\n end",
"def extractions_extraction_forms_projects_section_params\n params.require(:extractions_extraction_forms_projects_section)\n .permit(:extraction_id,\n :extraction_forms_projects_section_id,\n { status_attributes: [:name] },\n extractions_extraction_forms_projects_sections_type1s_attributes: [:type1_type_id, :units, {\n type1_attributes: %i[id name\n description], extractions_extraction_forms_projects_sections_type1_rows_attributes: [:_destroy, { population_name_attributes: %i[name description], extractions_extraction_forms_projects_sections_type1_row_columns_attributes: [:_destroy, :extractions_extraction_forms_projects_sections_type1_row_id, { timepoint_name_attributes: %i[name unit] }] }]\n }])\n end",
"def extractions_extraction_forms_projects_sections_type1_params\n params.require(:extractions_extraction_forms_projects_sections_type1)\n .permit(:type1_type_id, :extractions_extraction_forms_projects_section_id, :type1_id, :units,\n should: :propagate,\n type1_attributes: %i[id name description],\n extractions_extraction_forms_projects_sections_type1_rows_attributes: [\n :id, :_destroy,\n { population_name_attributes: %i[id name description],\n extractions_extraction_forms_projects_sections_type1_row_columns_attributes: [\n :id, :_destroy,\n { timepoint_name_attributes: %i[id name unit] }\n ] }\n ])\n end",
"def set_extractions_extraction_forms_projects_section\n @extractions_extraction_forms_projects_section = ExtractionsExtractionFormsProjectsSection.find(params[:id])\n end",
"def update\n respond_to do |format|\n if @extractions_extraction_forms_projects_section.update(extractions_extraction_forms_projects_section_params)\n format.html { redirect_to work_extraction_path(@extractions_extraction_forms_projects_section.extraction,\n anchor: \"panel-tab-#{ @extractions_extraction_forms_projects_section.id.to_s }\"),\n notice: t('success') }\n format.json { render :show, status: :ok, location: @extractions_extraction_forms_projects_section }\n else\n format.html { redirect_to work_extraction_path(@extractions_extraction_forms_projects_section.extraction,\n anchor: \"panel-tab-#{ @extractions_extraction_forms_projects_section.id.to_s }\"),\n alert: t('failure') }\n format.json { render json: @extractions_extraction_forms_projects_section.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @result_statistic_section.update(result_statistic_section_params)\n format.html { redirect_to edit_result_statistic_section_path(@result_statistic_section),\n notice: t('success') }\n format.json { render :show, status: :ok, location: @result_statistic_section }\n format.js do\n @eefpst1 = @result_statistic_section\n .population\n .extractions_extraction_forms_projects_sections_type1\n @extraction = @result_statistic_section.extraction\n @project = @result_statistic_section.project\n @extraction_forms_projects = @project.extraction_forms_projects\n @eefpst1s = ExtractionsExtractionFormsProjectsSectionsType1\n .by_section_name_and_extraction_id_and_extraction_forms_project_id('Outcomes',\n @extraction.id,\n @extraction_forms_projects.first.id)\n end\n else\n format.html { render :edit }\n format.json { render json: @result_statistic_section.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @section.update(section_params)\n @section.check_index()\n form_wrapper = FormWrapper.find(@section.form_wrapper_id)\n format.html { redirect_to sections_section_path(form_wrapper), alert: I18n.t('activerecord.models.section.single') + I18n.t('helpers_locale.models.created') }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @section.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @site_type = SiteType.find(params[:id])\n\n respond_to do |format|\n section_type_ids = params[:site_type].delete(\"section_type_ids\")\n if @site_type.update_attributes(params[:site_type]) && @site_type.section_type_ids = section_type_ids\n format.html { redirect_to @site_type, notice: 'Site type was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @site_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @step = @project.steps.find_by_position(params[:id])\n authorize! :update, @step \n\n # update corresponding collections\n @step.project.collections.each do |collection|\n collection.touch\n end\n \n @step.images.each do |image|\n image.update_attributes(:saved => true)\n end\n\n # remove question if question description is empty\n if params[:step][:question_attributes] && params[:step][:question_attributes][:description].length == 0 && @step.question\n @step.question.destroy\n end\n\n if params[:step][:published_on_date]\n date = params[:step][:published_on_date]\n logger.debug \"date: #{date}\"\n time = params[:step][:published_on_time]\n # retain the same seconds as the original published_on date\n time.insert 5, \":\" + @step.published_on.strftime(\"%S\")\n # logger.debug \"time: #{time}\"\n timeZone = params[:step][:timeZone]\n # logger.debug \"timeZone: #{timeZone}\"\n dateTime = date + \" \" + time + \" \" + timeZone\n # logger.debug \"dateTime: #{dateTime}\"\n dateTime = DateTime.strptime(dateTime, '%m/%d/%Y %I:%M:%S %p %Z')\n # logger.debug \"datetime: #{dateTime}\"\n \n params[:step][:published_on] = dateTime\n params[:step].delete :'published_on_date'\n params[:step].delete :\"published_on_time\"\n params[:step].delete :timeZone\n end\n\n # update the project \n @project.touch\n\n # update the user last updated date\n current_user.touch\n\n # remove any design attributes if they contain an ID that doesn't exist (the file had been removed)\n if params[:step][:design_files_attributes]\n params[:step][:design_files_attributes].values.each do |design_file|\n if DesignFile.exists?(design_file['id']) == false\n design_file.delete :id\n end\n end\n end\n \n respond_to do |format|\n\n if @step.update_attributes(params[:step])\n \n # clear label color if user didn't select color\n if @step.label == false\n @step.update_column(\"label_color\", nil)\n end\n\n # clear edit\n edit = Edit.where(\"user_id = ? AND step_id = ?\", current_user.id, @step.id).first\n edit.update_attributes(:started_editing_at => nil)\n if edit.project_id.blank?\n edit.update_attributes(:project_id => @project.id)\n end\n \n # check whether project is published\n if @project.public? || @project.privacy.blank?\n @project.set_published(current_user.id, @project.id, @step.id)\n end\n\n # check and set built attribute of project\n @project.set_built\n\n # create a public activity for any questions associated with the step if it doesn't already exist\n if @step.question && !PublicActivity::Activity.where(:trackable_type => \"Question\").where(:trackable_id => @step.question.id).exists?\n @step.question.create_activity :create, owner: current_user, primary: true\n end\n\n # create project on the village if the current user is a village user and the project doesn't already exist\n if @project.village_id.blank? && current_user.from_village? && !access_token.blank? && @project.public?\n create_village_project\n elsif !@project.village_id.blank? && !access_token.blank?\n update_village_project\n end\n\n format.html { \n redirect_to project_steps_path(@project), :notice => 'Step was successfully updated.', :flash => {:createdStep => @step.id} \n }\n format.json { head :no_content }\n else\n Rails.logger.info(@step.errors.inspect)\n format.html { render :action => \"edit\" }\n format.json { render :json => @step.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n @entry_type = EntryType.find(params[:id])\n\n respond_to do |format|\n field_type_ids = params[:entry_type].delete(\"field_type_ids\")\n @entry_type.field_type_ids = field_type_ids if field_type_ids\n params[:entry_type].delete(\"form_code\")\n if @entry_type.update_attributes(params[:entry_type])\n format.html { redirect_to @entry_type, notice: 'Entry type was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @entry_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @resource_type.update_attributes(params[:resource_type])\n if params[:fields]\n params[:fields].each do |param|\n if param[:id]\n @field = Field.find(param[:id])\n @field.update_attributes(\n :name => param[:name], \n :field_type_id => param[:field_type_id],\n :resource_type_id => params[:id],\n :resource_type_reference_id => param[:resource_type_reference_id]\n )\n else\n @field = Field.create(\n :name => param[:name],\n :field_type_id => param[:field_type_id],\n :resource_type_id => params[:id],\n :resource_type_reference_id => param[:resource_type_reference_id]\n )\n end\n if @field.field_validations.any?\n @field.field_validations.each { |v| v.destroy }\n end\n if param[:validator_ids]\n param[:validator_ids].each do |index|\n next if index == \"multiselect-all\"\n @field.field_validations.build(validator_id: index.to_i)\n end\n end \n @field.save\n end\n end \n format.html { redirect_to @resource_type, notice: 'Resource type was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @resource_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @defect_type.update(defect_type_params)\n format.html { redirect_to @defect_type, notice: 'Defect type was successfully updated.' }\n format.json { render :show, status: :ok, location: @defect_type }\n else\n format.html { render :edit }\n format.json { render json: @defect_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n params[:product_section][:audit_user_name] = current_user.full_name\n @fo = @product_section.product.room.fabrication_order_id\n if @product_section.update(product_section_params)\n\n params_redirect = {id: @fo}\n params_redirect.merge!({scroll: true}) if params[:scroll]\n\n format.html { redirect_to edit_fabrication_order_path(params_redirect), notice: 'Section was successfully updated.' }\n format.json do\n flash[:notice] = \"status for #{@product_section.name} was successfully updated\"\n sects = {id: @product_section.id, name: @product_section.name, status: @product_section.status, size_type: @product_section.size_type, size_a: @product_section.size_a, fraction_size_a: @product_section.fraction_size_a, size_b: @product_section.size_b, fraction_size_b: @product_section.fraction_size_a, edge_type_a_id: @product_section.edge_type_a_id, edge_type_a: @product_section.edge_type_a.to_s, edge_type_b: @product_section.edge_type_b.to_s, edge_type_b_id: @product_section.edge_type_b_id, edge_type_c: @product_section.edge_type_c.to_s, edge_type_c_id: @product_section.edge_type_c_id, edge_type_d: @product_section.edge_type_d.to_s, edge_type_d_id: @product_section.edge_type_d_id}\n render json: api_response(:success, nil, sects)\n end \n format.js {render layout: false}\n else\n format.html {\n set_edge_type\n renderr = product_section_params.has_key?(:size_a) ? :size : :edit\n render renderr, :layout => \"application\" \n }\n format.json { render json: api_response(:failed, @product_section.errors.full_messages.join(' '), @product_section.errors), status: :unprocessable_entity }\n format.js\n end\n end\n end",
"def update\n\n # workflow_attributes = workflow_params\n # step_definitions_attributes = workflow_attributes.delete(\"step_definitions\")\n\n # StepDefinition.updateStepDefinitions(step_definitions_attributes)\n\n respond_to do |format|\n if @workflow.update(workflow_params)\n format.html { redirect_to @workflow, notice: 'Workflow was successfully updated.' }\n format.json { render :show, status: :ok, location: @workflow }\n else\n format.html { render :edit }\n format.json { render json: @workflow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n section_chunks = get_chunks(params)\n\n puts params\n redirect_to @course\n\n return\n\n sections = params['sections']\n if sections.nil?\n # Loop through course's existing sections.\n @course.sections.each do |section|\n\n end\n end\n \n respond_to do |format|\n # Update subcontents\n if update_section_chunks(section_chunks)\n format.html { redirect_to @course }\n format.json { render :show, status: :ok, location: @course }\n else\n format.html { render :edit }\n format.json { render json: @course.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize @work_type\n respond_to do |format|\n if @work_type.update(work_type_params)\n format.html { redirect_to work_types_url, notice: t('Record has been saved') }\n format.json { render :show, status: :ok, location: @work_type }\n else\n format.html {\n @work_type.work_type_tools.build if @work_type.work_type_tools.blank?\n @work_type.work_type_materials.build if @work_type.work_type_materials.blank?\n @work_type.work_type_others.build if @work_type.work_type_others.blank?\n @work_type.work_type_additionals.build if @work_type.work_type_additionals.blank?\n render :edit\n }\n format.json { render json: @work_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n authorize(@extraction)\n redirect_path = params[:redirect_to]\n\n respond_to do |format|\n if @extraction.update(extraction_params)\n format.html do\n redirect_to(\n redirect_path || work_extraction_path(@extraction,\n 'panel-tab': params[:extraction][:extraction_forms_projects_section_id]),\n notice: t('success')\n )\n end\n format.json { render :show, status: :ok, location: @extraction }\n format.js\n else\n format.html { render :edit }\n format.json { render json: @extraction.errors, status: :unprocessable_entity }\n format.js\n end\n end\n end",
"def edit\n add_breadcrumb 'edit project', edit_project_path(@result_statistic_section.extraction.project)\n add_breadcrumb 'extractions', project_extractions_path(@result_statistic_section.extraction.project)\n add_breadcrumb 'work', work_extraction_path(@result_statistic_section.extraction,\n params: { eefpst1_id: @result_statistic_section.population.extractions_extraction_forms_projects_sections_type1_id },\n anchor: \"panel-tab-#{ @result_statistic_section.eefps_result.id }\")\n add_breadcrumb @result_statistic_section.result_statistic_section_type.name.downcase,\n :edit_result_statistic_section_path\n end",
"def create\n authorize(@extractions_extraction_forms_projects_sections_type1.project, policy_class: ExtractionsExtractionFormsProjectsSectionsType1RowPolicy)\n\n @extractions_extraction_forms_projects_sections_type1_row = @extractions_extraction_forms_projects_sections_type1.extractions_extraction_forms_projects_sections_type1_rows.build(extractions_extraction_forms_projects_sections_type1_row_params)\n\n respond_to do |format|\n if @extractions_extraction_forms_projects_sections_type1_row.save\n format.html { redirect_to edit_timepoints_extractions_extraction_forms_projects_sections_type1_path(@extractions_extraction_forms_projects_sections_type1),\n notice: t('success') }\n format.json { head :no_content }\n else\n format.html { render '/extractions_extraction_forms_projects_sections_type1s/edit_timepoints' }\n format.json { render :json => @extractions_extraction_forms_projects_sections_type1_row.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @lab_section.update(lab_section_params)\n format.html { redirect_to @lab_section, notice: 'Lab section was successfully updated.' }\n format.json { render :show, status: :ok, location: @lab_section }\n else\n format.html { render :edit }\n format.json { render json: @lab_section.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @patent = Patent.find(params[:id])\n\n respond_to do |format|\n if params[:patent][:research_areas]\n research_area = ResearchArea.find(params[:patent][:research_areas].to_i)\n @patent.research_areas << research_area\n @patent.save\n format.json { render json: research_area }\n elsif @patent.update_attributes(params[:patent])\n format.html { redirect_to @patent, notice: 'Patent was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @patent.errors, status: :unprocessable_entity }\n end\n end\n end",
"def UpdateField params = {}\n \n APICall(path: 'ticket_fields.json',method: 'PUT',payload: params.to_json)\n \n end",
"def update\n respond_to do |format|\n if @story_part.update(story_part_params)\n format.html { redirect_to @story_part, notice: 'Story part was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @story_part.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n # { subsection:\n # {\n # \"id\" : id\n # \"subsection_datum_id\":references\n # }\n # }\n if @subsection.update_attributes(params[:module])\n head :no_content\n else\n render json: @subsection.errors.full_messages,\n status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @foundation_type.update(foundation_type_params)\n format.html { redirect_to @foundation_type, notice: 'Foundation type was successfully updated.' }\n format.json { render :show, status: :ok, location: @foundation_type }\n else\n format.html { render :edit }\n format.json { render json: @foundation_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\r\n @theoretical_part = TheoreticalPart.find(params[:id])\r\n\r\n respond_to do |format|\r\n if @theoretical_part.update_attributes(params[:theoretical_part])\r\n format.html { redirect_to @theoretical_part, notice: 'Theoretical part was successfully updated.' }\r\n format.json { head :no_content }\r\n else\r\n format.html { render action: \"edit\" }\r\n format.json { render json: @theoretical_part.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def destroy\n @extractions_extraction_forms_projects_sections_type1.destroy\n respond_to do |format|\n format.html { redirect_to work_extraction_path(@extractions_extraction_forms_projects_sections_type1\n .extractions_extraction_forms_projects_section\n .extraction,\n anchor: \"panel-tab-#{ @extractions_extraction_forms_projects_sections_type1\n .extractions_extraction_forms_projects_section.id }\"),\n notice: t('removed') }\n format.json { head :no_content }\n end\n end",
"def update\n respond_to do |format|\n if @portfolio_section.update(portfolio_section_params)\n format.html { redirect_to @portfolio_section, notice: \"Portfolio section was successfully updated.\" }\n format.json { render :show, status: :ok, location: @portfolio_section }\n else\n format.html { render :edit, status: :unprocessable_entity }\n format.json { render json: @portfolio_section.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n step_definition_attributes = step_definition_params\n field_definitions_attributes = step_definition_attributes.delete(\"field_definitions\")\n\n FieldDefinition.updateFieldDefinitions(field_definitions_attributes)\n\n respond_to do |format|\n if @step_definition.update(step_definition_attributes)\n format.html { redirect_to @step_definition, notice: 'Step definition was successfully updated.' }\n format.json { render :show, status: :ok, location: @step_definition }\n else\n format.html { render :edit }\n format.json { render json: @step_definition.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @project_type_workflow.update(project_type_workflow_params)\n format.html { redirect_to @project_type_workflow, notice: 'Project type workflow was successfully updated.' }\n format.json { render :show, status: :ok, location: @project_type_workflow }\n else\n format.html { render :edit }\n format.json { render json: @project_type_workflow.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n params[:workout][:workout_date] = \"#{params[:workout][:workout_date]} #{params[:workout][:time]}\"\n params[:workout] = params[:workout].slice(:workout_date, :exercises_attributes)\n @lift_name = params[:workout][:exercises_attributes][\"0\"][:lift_id]\n params[:workout][:exercises_attributes][\"0\"][:lift_id] = Lift.find_by_lift_name(@lift_name).id\n @workout = Workout.find(params[:id])\n\n respond_to do |format|\n if @workout.update_attributes(params[:workout])\n format.html { redirect_to @workout, notice: 'Workout was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @workout.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @property_toilet_artifact.update(property_toilet_artifact_params)\n format.html { redirect_to @property_toilet_artifact, notice: 'Property toilet artifact was successfully updated.' }\n format.json { render :show, status: :ok, location: @property_toilet_artifact }\n else\n format.html { render :edit }\n format.json { render json: @property_toilet_artifact.errors, status: :unprocessable_entity }\n end\n end\n end",
"def destroy\n @extractions_extraction_forms_projects_sections_type1.destroy\n respond_to do |format|\n format.html do\n redirect_to work_extraction_path(@extractions_extraction_forms_projects_sections_type1\n .extractions_extraction_forms_projects_section\n .extraction,\n 'panel-tab': @extractions_extraction_forms_projects_sections_type1\n .extractions_extraction_forms_projects_section\n .extraction_forms_projects_section\n .id),\n notice: t('removed')\n end\n format.json { head :no_content }\n end\n end",
"def update\n respond_to do |format|\n if @type_project.update(type_project_params)\n\n format.html { redirect_to @type_project, notice: 'Type project was successfully updated.' }\n format.json { render :show, status: :ok, location: @type_project }\n else\n format.html { render :edit }\n format.json { render json: @type_project.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @spec_type.update(spec_type_params)\n format.html { redirect_to @spec_type, notice: 'Spec type was successfully updated.' }\n format.json { render :show, status: :ok, location: @spec_type }\n else\n format.html { render :edit }\n format.json { render json: @spec_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @court_complex.update(court_complex_params)\n format.html { redirect_to @court_complex, notice: 'Court complex was successfully updated.' }\n format.json { render :show, status: :ok, location: @court_complex }\n else\n format.html { render :edit }\n format.json { render json: @court_complex.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @use_case = UseCase.find(params[:id])\n @use_case.data = params[:data].to_json\n\n respond_to do |format|\n if @use_case.update_attributes(params[:use_case])\n\n if params[:subaction]==\"step\"\n format.html { redirect_to requirements_project_use_case_path(@use_case.project, @use_case, :type=>\"step\"), notice: 'Use case was successfully updated.' }\n else\n format.html { redirect_to project_use_case_path(@project, @use_case), notice: 'Use case was successfully updated.' }\n end\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @use_case.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @doc_type.update(doc_type_params)\n format.html { redirect_to @doc_type, notice: t('message.template.scaffold.update', model: t('activerecord.models.doc_type')) }\n format.json { render :show, status: :ok, location: @doc_type }\n else\n format.html { render :edit }\n format.json { render json: @doc_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n step_attributes = step_params\n fields_attributes = step_attributes.delete(\"fields\")\n\n Field.updateFields(fields_attributes)\n\n respond_to do |format|\n if @step.update(step_attributes)\n format.html { redirect_to @step, notice: 'Step was successfully updated.' }\n format.json { render :show, status: :ok, location: @step }\n else\n format.html { render :edit }\n format.json { render json: @step.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @tool_part.update_attributes(params[:tool_part])\n format.html { redirect_to @tool_part, notice: I18n.t('controllers.update_success', name: @tool_part.class.model_name.human) }\n format.json { head :no_content }\n format.xml { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @tool_part.errors, status: :unprocessable_entity }\n format.xml { render xml: @tool_part.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @project = Project.find(params[:project_id])\n @material_usage = @project.material_usages.find(params[:id])\n @material_usage.material = @project.materials.find_by_id(params[:material_usage][:material_id])\n @material_usage.phase = @project.phases.find_by_id(params[:material_usage][:phase_id])\n\n respond_to do |format|\n if @material_usage.update_attributes(params[:material_usage].except(:material_id, :phase_id))\n format.html { redirect_to [@project, @material_usage], notice: 'Material usage was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @material_usage.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @education_service_provided_typology.update(education_service_provided_typology_params)\n format.html { redirect_to @education_service_provided_typology, notice: 'Education service provided typology was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @education_service_provided_typology.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @project_type.update(project_type_params)\n format.html { redirect_to @project_type, notice: 'Project type was successfully updated.' }\n format.json { render :show, status: :ok, location: @project_type }\n else\n format.html { render :edit }\n format.json { render json: @project_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @project_type.update(project_type_params)\n format.html { redirect_to @project_type, notice: 'Project type was successfully updated.' }\n format.json { render :show, status: :ok, location: @project_type }\n else\n format.html { render :edit }\n format.json { render json: @project_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @singlepart.update(singlepart_params)\n format.html { redirect_to @singlepart, notice: 'Singlepart was successfully updated.' }\n format.json { render :show, status: :ok, location: @singlepart }\n else\n format.html { render :edit }\n format.json { render json: @singlepart.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @section_heading.update(section_heading_params)\n format.html { redirect_to @section_heading, notice: 'Section heading was successfully updated.' }\n format.json { render :show, status: :ok, location: @section_heading }\n else\n format.html { render :edit }\n format.json { render json: @section_heading.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n if section.update_attributes(params[:section_datum])\n head :no_content\n else\n render json: section.errors.full_messages,\n status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @part.update(part_params)\n format.html { redirect_to chaper_path(@chaper), notice: 'Part was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: chaper_path(@chaper).errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n @foaf.interests.clear\n\n if(foaf_params.has_key?(:interests_attributes))\n interest_ids = foaf_params[:interests_attributes].split(\",\").map { |s| s.to_i }\n interest_ids.each do |i|\n @foaf.interests << Interest.find(i)\n #@foaf.update(Interest.find(i))\n end\n \n end\n\n respond_to do |format|\n if @foaf.update(name: foaf_params[:name], work: foaf_params[:work], \n slug: foaf_params[:slug], birthday: foaf_params[:birthday])\n format.html { redirect_to @foaf, notice: 'Foaf was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @foaf.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @callout.update(callout_params)\n format.html { redirect_to @callout, notice: 'Callout was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @callout.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @interaction_type.update(interaction_type_params)\n format.html { redirect_to @interaction_type, notice: 'Interaction type was successfully updated.' }\n format.json { render :show, status: :ok, location: @interaction_type }\n else\n format.html { render :edit }\n format.json { render json: @interaction_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @soa_section.update(soa_section_params.merge({serial_number: @soa_section.serial_number += 1, revision: @soa_section.revision += 1 }))\n format.html { redirect_to domain_dns_zone_path(@soa_section.dns_zone.domain, @soa_section.dns_zone), notice: 'Soa section was successfully updated.' }\n format.json { head :no_content }\n else\n format.html do\n flash[:alert] = \"SoaSection validation failed: #{@soa_section.errors.messages}\"\n render action: :edit\n end\n format.json { render json: @soa_section.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n respond_to do |format|\n parameters = params[:project].slice(:project, :target_completion, :status, :notes)\n if parameters.has_key? :target_completion\n date = Date.parse(parameters[:target_completion])\n parameters[:target_completion] = date #unless date.nil?\n end\n if @project.update_attributes(parameters)\n format.html { redirect_to @project, notice: 'Project was successfully updated.' }\n format.json { respond_with_bip(@project)}#head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { respond_with_bip(@project)}#render json: @project.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n params[:project][:analysis_ids]\n \n @project = Project.find(params[:id])\n\n respond_to do |format|\n if @project.update_attributes(params[:project])\n format.html { redirect_to :action => 'analyses', notice: 'Project was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @project.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @tool_type.update(tool_type_params)\n format.html { redirect_to @tool_type, notice: 'Tool type was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @tool_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @section_heading = SectionHeading.find(params[:id])\n\n respond_to do |format|\n if @section_heading.update_attributes(params[:section_heading])\n format.html { redirect_to @section_heading, notice: 'Section heading was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @section_heading.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n @foaf.interests.clear\n\n if(foaf_params.has_key?(:interests_attributes))\n interest_ids = foaf_params[:interests_attributes].split(\",\").map { |s| s.to_i }\n interest_ids.each do |i|\n @foaf.interests << Interest.find(i)\n #@foaf.update(Interest.find(i))\n end\n \n end\n\n respond_to do |format|\n if @foaf.update(name: foaf_params[:name], work: foaf_params[:work], \n slug: foaf_params[:slug], birthday: foaf_params[:birthday])\n format.html { redirect_to @foaf, notice: 'FOAF was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @foaf.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_api_definition_file\n if @research_tool.update(research_tool_params)\n redirect_to [:api_definition, :admin, @research_tool], notice: 'Research Tool was successfully updated.'\n else\n render :api_definition\n end\n end",
"def update\n @study = Study.find(params[:id])\n @project = Project.find(@study.project_id)\n #@project = Project.find(session[:project_id])\n #@study = Study.set_study_type(params, @study)\n if @saved = @study.update_attributes(params[:study])\n questions_flag = false\n questions = get_questions_params(params)\n # if we're updating from the key question form,\n # remove previously saved questions for this study\n kq_error = false\n unless params[:updating_kq].nil?\n # if there are question parameters, save the new entries\n unless questions.empty?\n @study.assign_questions(questions, params[:extraction_form_id])\n else\n flash[:error] = \"This operation is not allowed. Studies must be associated with at least one key question.\"\n kq_error = true\n end\n end\n end\n @study_extforms = StudyExtractionForm.where(:study_id => @study.id)\n @study_extforms.uniq!\n @extraction_forms = @study.get_extraction_forms\n @included_sections = Hash.new\n @borrowed_section_names, @section_donor_ids = [Hash.new,Hash.new]\n # an array of hashes to keep track of key questions addressed by\n # each individual section\n @kqs_per_section = Hash.new\n unless @study_extforms.empty?\n @study_extforms.each do |ef|\n tmpForm = ExtractionForm.find(ef.extraction_form_id)\n @extraction_forms << tmpForm\n included = ExtractionFormSection.get_included_sections(ef.extraction_form_id)\n borrowed = ExtractionFormSection.get_borrowed_sections(ef.extraction_form_id)\n @included_sections[ef.extraction_form_id] = included\n @borrowed_section_names[ef.extraction_form_id] = borrowed.collect{|x| x[0]}\n @section_donor_ids[ef.extraction_form_id] = borrowed.collect{|x| x[1]}\n @kqs_per_section[ef.extraction_form_id] = ExtractionFormSection.get_questions_per_section(ef.extraction_form_id,@study)\n end\n end\t\n redirect_to \"/projects/#{@project.id}/studies/#{@study.id}/edit\"\n end",
"def update\n respond_to do |format|\n if @part_attribute.update(part_attribute_params)\n format.html { redirect_to @part_attribute, notice: 'Part attribute was successfully updated.' }\n format.json { render :show, status: :ok, location: @part_attribute }\n else\n format.html { render :edit }\n format.json { render json: @part_attribute.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n\n sub_obj_non_attributes = study_params.select { |key| !key.to_s.match(/_attributes$/) }\n\n @study = Study.find(session[:current_study_id])\n\n \n if ! sub_obj_non_attributes.empty?\n @study.update(sub_obj_non_attributes.to_h.except('_destroy', 'id', 'rec_id', 'updated', 'rec_delete'))\n end\n \n traverse_study_attr(study_params.select { |key| key.to_s.match(/_attributes$/)}, @study)\n \n respond_to do |format|\n format.html { redirect_to study_steps_path}\n format.json { render action: 'show', status: :created, location: @study }\n\n end\n\n end",
"def update\n respond_to do |format|\n if @typetutorial.update(typetutorial_params)\n format.html { redirect_to @typetutorial, notice: 'Typetutorial was successfully updated.' }\n format.json { render :show, status: :ok, location: @typetutorial }\n else\n format.html { render :edit }\n format.json { render json: @typetutorial.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @security_proj_type = SecurityProjType.find(params[:id])\n\n respond_to do |format|\n if @security_proj_type.update_attributes(params[:security_proj_type])\n format.html { redirect_to @security_proj_type, notice: 'Security proj type was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @security_proj_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @section.update(section_params)\n format.html { redirect_to @section, notice: 'Section was successfully updated.' }\n format.json { render json: @section }\n else\n format.html { render action: 'edit' }\n format.json { render json: ErrorSerializer.serialize(@section.errors), status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @reference_type.update_attributes(params[:reference_type])\n flash[:notice] = 'Reference type was successfully updated.'\n @changed << @reference_type.id\n\n format.html { redirect_to reference_types_path }\n format.js { render 'shared/index'; flash.discard }\n format.json { head :no_content }\n else\n @edited << @reference_type.id\n @expanded << @reference_type.id\n\n format.html { render action: 'edit', template: 'shared/edit' }\n format.js { render 'reference_type' }\n format.json { render json: @reference_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @subpart.update(subpart_params)\n format.html { redirect_to @subpart, notice: 'Subpart was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @subpart.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @major.update(major_params)\n format.html { redirect_to @major, notice: 'Major was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @major.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @api_v1_initiative_field.update(api_v1_initiative_field_params)\n format.html { redirect_to @api_v1_initiative_field, notice: 'Initiative field was successfully updated.' }\n format.json { render :show, status: :ok, location: @api_v1_initiative_field }\n else\n format.html { render :edit }\n format.json { render json: @api_v1_initiative_field.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @section_test = SectionTest.find(params[:id])\n\n respond_to do |format|\n if @section_test.update_attributes(params[:section_test])\n format.html { redirect_to @section_test, notice: 'Section test was successfully updated.' }\n format.json { head :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @section_test.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @type_expertise = TypeExpertise.find(params[:id])\n\n respond_to do |format|\n if @type_expertise.update_attributes(params[:type_expertise])\n format.html { redirect_to(@type_expertise, :notice => 'Type expertise was successfully updated.') }\n format.xml { head :ok }\n format.json {render :json => {\"success\"=>true,\"data\"=>@type_expertise}}\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @type_expertise.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @project_step.update(project_step_params)\n format.html { redirect_to @project_step, notice: 'Project step was successfully updated.' }\n format.json { render :show, status: :ok, location: @project_step }\n else\n format.html { render :edit }\n format.json { render json: @project_step.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @interview_type.update(interview_type_params)\n format.html { redirect_to @interview_type, notice: 'Interview type was successfully updated.' }\n format.json { render :show, status: :ok, location: @interview_type }\n else\n format.html { render :edit }\n format.json { render json: @interview_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @issue_type.update(issue_type_params)\n format.html { redirect_to @issue_type, notice: 'Issue type was successfully updated.' }\n format.json { render :show, status: :ok, location: @issue_type }\n else\n format.html { render :edit }\n format.json { render json: @issue_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @company_part.update(company_part_params)\n format.html { redirect_to company_parts_path, notice: 'Company part was successfully updated.' }\n format.json { render :show, status: :ok, location: @company_part }\n else\n format.html { render :edit }\n format.json { render json: @company_part.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @work.update_attributes(params[:work])\n format.html { redirect_to @work, :notice => 'Obra atualizada com sucesso!' }\n format.json { head :no_content }\n else\n 1.times { @work.work_documents.build }\n load_cities_validate()\n format.html { render :action => \"edit\" }\n format.json { render :json => @work.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n action_message_for(@collection.content_item.status)\n if update_collection\n format.html { redirect_to redirect_target(@collection), flash: @feedback_flash }\n format.json { render :show, status: :ok, location: @collection }\n else\n 1.times { @collection.collection_sections.new } if @collection.collection_sections.empty?\n @collection.collection_sections.each do |section|\n (6 - section.section_items.size).times { section.section_items.new }\n end\n @collection.content_item.status = session[:content_item_status]\n format.html { render :edit }\n format.json { render json: @collection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @tutorial_section.update(tutorial_section_params)\n format.html { redirect_to @tutorial_section, notice: 'Tutorial section was successfully updated.' }\n format.json { render :show, status: :ok, location: @tutorial_section }\n else\n format.html { render :edit }\n format.json { render json: @tutorial_section.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n # { clinic: {id: references, \"license_id\"=>nil, \"name\"=>string } }\n \n if @clinic.update_attributes(params[:clinic].except(:api_license_id))\n head :no_content\n else\n render json: clinic.errors.full_messages, status: :unprocessable_entity\n end\n end",
"def update\n respond_to do |format|\n if @contact_medium_type.update(contact_medium_type_params)\n format.html { redirect_to @contact_medium_type, notice: 'Contact medium type was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: 'edit' }\n format.json { render json: @contact_medium_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @parts_for_proposal.update(parts_for_proposal_params)\n curr_id = @parts_for_proposal.proposal_id\n format.html { redirect_to proposal_url(:id => curr_id), notice: 'Part configuration update was successfull.' }\n format.json { render :show, status: :ok, location: @parts_for_proposal }\n else\n format.html { render :edit }\n format.json { render json: @parts_for_proposal.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @projects_and_concept.update(projects_and_concept_params)\n format.html { redirect_to @projects_and_concept, notice: 'Projects and concept was successfully updated.' }\n format.json { render :show, status: :ok, location: @projects_and_concept }\n else\n format.html { render :edit }\n format.json { render json: @projects_and_concept.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @tutorial = Tutorial.find(params[:id])\n editUpdate = params[:tutorial]\n hideUpdate = editUpdate.extract_keys!([:hidden])\n adminUpdate = editUpdate.extract_keys!([:featured])\n success = false\n \n #EDIT REQUEST\n if can_edit?(@tutorial) \n success = @tutorial.update_attributes(editUpdate)\n end\n \n #HIDE REQUEST\n if can_hide?(@tutorial) \n success = @tutorial.update_attributes(hideUpdate)\n end\n \n #ADMIN REQUEST\n if can_admin?(@tutorial)\n if adminUpdate.has_key?(:featured)\n if adminUpdate['featured'] == true\n adminUpdate['featured_at'] = Time.now()\n else\n adminUpdate['featured_at'] = nil\n end\n end\n \n success = @tutorial.update_attributes(adminUpdate)\n end\n\n respond_to do |format|\n if success\n format.html { redirect_to @tutorial, notice: 'Tutorial was successfully updated.' }\n format.json { render json: {}, status: :ok }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @tutorial.errors.full_messages(), status: :unprocessable_entity }\n end\n end\n end",
"def update\n respond_to do |format|\n if @feature.update_attributes(params[:feature])\n flash[:notice] = 'Feature was successfully updated.'\n @changed << @feature.id\n\n format.html { redirect_to features_path }\n format.js { render 'shared/index'; flash.discard }\n format.json { head :no_content }\n else\n @edited << @feature.id\n @expanded << @feature.id\n\n format.html { render action: 'edit', template: 'shared/edit' }\n format.js { render 'feature' }\n format.json { render json: @feature.errors, status: :unprocessable_entity }\n end\n end\n end",
"def edit\n if !params[:project_id] && !params[:study_id] && !params[:id]\n flash[\"error\"] = \"To add a new study, please choose a systematic review first.\"\n redirect_to projects_paths\n else \n @study = Study.find(params[:id])\n #puts \"---------------------\\n THE STUDY ID IS #{@study.id}\\n\\n\"\n @study_extforms = StudyExtractionForm.find(:all, :conditions=>[\"study_id=?\",@study.id],:select=>[\"id\",\"study_id\",\"extraction_form_id\"],:order=>\"extraction_form_id ASC\")\n @extraction_forms = Array.new\n\n # an array of hashes to keep track of key questions addressed by\n # each individual section\n @ef_kqs = Hash.new()\n unless @study_extforms.empty?\n @study_extforms.each do |ef|\n @ef_kqs[ef.extraction_form_id] = ExtractionForm.get_assigned_question_numbers(ef.extraction_form_id)\t\n end\n end\t \n session[:project_id] = @study.project_id \n @project = Project.find(@study.project_id)\n\n unless @study_extforms.empty?\t\t\t\n # get the study title, which is the same as the primary publication for the study\n @study_title = PrimaryPublication.where(:study_id => @study.id).first\n @study_title = @study_title.nil? ? \"\" : @study_title.title.to_s\t\n #@extraction_form_list_array = Study.get_extraction_form_list_array(session[:project_id])\n @extraction_forms = ExtractionForm.find(:all, :conditions=>[\"id in (?)\",@study_extforms.collect{|x| x.extraction_form_id}])\n @current_form_id = params[:extraction_form_id].nil? ? @extraction_forms.first.id : params[:extraction_form_id].to_i\n @included_sections = ExtractionForm.get_included_sections(@current_form_id)\n end\t\t\t\n # Set up the session variables\n makeStudyActive(@study)\n session[:extraction_form_id] = @current_form_id\n session[:completed_sections] = Study.get_completed_sections(@study.id, @current_form_id)\n end\n end",
"def update\n @domicile_type_section = DomicileTypeSection.find(params[:id])\n\n respond_to do |format|\n if @domicile_type_section.update_attributes(params[:domicile_type_section])\n format.html { redirect_to(@domicile_type_section, :notice => 'Domicile type section was successfully updated.') }\n format.xml { head :ok }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @domicile_type_section.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def set_sections_with_http_info(name, sections, password = nil, folder = nil, storage = nil)\n if @api_client.config.debugging\n @api_client.config.logger.debug 'Calling API: SlidesApi.set_sections ...'\n end\n\n # verify the required parameter 'name' is set\n if @api_client.config.client_side_validation && name.nil?\n fail ArgumentError, \"Missing the required parameter 'name' when calling SlidesApi.set_sections\"\n end\n # verify the required parameter 'sections' is set\n if @api_client.config.client_side_validation && sections.nil?\n fail ArgumentError, \"Missing the required parameter 'sections' when calling SlidesApi.set_sections\"\n end\n # resource path\n local_var_path = '/slides/{name}/sections'\n local_var_path = @api_client.replace_path_parameter(local_var_path, 'name', name)\n\n # query parameters\n query_params = {}\n query_params[:'folder'] = @api_client.prepare_for_query(folder) unless folder.nil?\n query_params[:'storage'] = @api_client.prepare_for_query(storage) unless storage.nil?\n\n # header parameters\n header_params = {}\n # HTTP header 'Accept' (if needed)\n header_params['Accept'] = @api_client.select_header_accept(['application/json'])\n # HTTP header 'Content-Type'\n header_params['Content-Type'] = @api_client.select_header_content_type(['application/json'])\n header_params[:'password'] = password unless password.nil?\n\n # http body (model)\n post_body = @api_client.object_to_http_body(sections)\n\n # form parameters\n post_files = []\n\n auth_names = ['JWT']\n data, status_code, headers = @api_client.call_api(:PUT, local_var_path,\n :header_params => header_params,\n :query_params => query_params,\n :body => post_body,\n :files => post_files,\n :auth_names => auth_names,\n :return_type => 'Sections')\n return data, status_code, headers\n end",
"def update\n @form_section.update(form_section_params)\n respond_with( [ :admin, @form_section] )\n end",
"def update_defect fields\n defect = @rally_api.find(:defect) { equal :formatted_i_d,\n fields[:formatted_i_d] }.first\n fields.delete_if { |name, val| val == defect.send(name) }\n defect.update(fields)\n end",
"def update\n respond_to do |format|\n if @hydralic_particular.update(hydralic_particular_params)\n format.html { redirect_to project_sub_project_hydralic_particulars_path(@project, @sub_project, :hydralic_type => @hydralic_particular.hydralic_type), notice: 'Hydralic particular was successfully updated.' }\n format.json { render :show, status: :ok, location: @hydralic_particular }\n else\n format.html { render :edit }\n format.json { render json: @hydralic_particular.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @image_section = ImageSection.find(params[:id])\n ci = @image_section.combined_image\n\n respond_to do |format|\n if @image_section.update_attribute(:sketchpad_json, params[:drawn_json])\n format.html { redirect_to edit_image_section_path(ci.image_sections.sample), \n notice: 'Image section was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @image_section.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n populate_flash @workshop.update_attributes(strong_type params)\n respond_to do |format|\n format.html { redirect_to edit_workshop_path(@workshop.year) + '/' + params[:fieldset] }\n end\n end",
"def update\n respond_to do |format|\n if @subsection.update(subsection_params)\n format.html { redirect_to @subsection, notice: 'Subsection was successfully updated.' }\n format.json { render :show, status: :ok, location: @subsection }\n else\n format.html { render :edit }\n format.json { render json: @subsection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update\n @section = Section.find(params[:id])\n\n respond_to do |format|\n if @section.update_attributes(params[:section])\n format.html { redirect_to @section, notice: 'Section was successfully updated.' }\n format.json { head :no_content }\n else\n format.html { render action: \"edit\" }\n format.json { render json: @section.errors, status: :unprocessable_entity }\n end\n end\n end",
"def patch(type, info)\n path, info = type_info(type, :path), force_case(info)\n ida = type == :client ? 'client_id' : 'id'\n raise ArgumentError, \"info must include #{ida}\" unless id = info[ida]\n hdrs = headers\n if info && info['meta'] && (etag = info['meta']['version'])\n hdrs.merge!('if-match' => etag)\n end\n reply = json_parse_reply(@key_style,\n *json_patch(@target, \"#{path}/#{Addressable::URI.encode(id)}\", info, hdrs))\n\n # hide client endpoints that are not quite scim compatible\n type == :client && !reply ? get(type, info['client_id']): reply\n end"
] |
[
"0.71862346",
"0.71666884",
"0.6797903",
"0.67297965",
"0.64738977",
"0.6439036",
"0.6389619",
"0.6322907",
"0.6301197",
"0.6295501",
"0.62587935",
"0.5670713",
"0.56633794",
"0.56380713",
"0.55923945",
"0.55866194",
"0.5577865",
"0.555775",
"0.55483025",
"0.55263823",
"0.5478186",
"0.54774016",
"0.5452923",
"0.5433314",
"0.5429708",
"0.54116195",
"0.5400244",
"0.537816",
"0.5378095",
"0.5369892",
"0.5367233",
"0.53458416",
"0.5330185",
"0.5317744",
"0.5317551",
"0.5312921",
"0.53026766",
"0.529931",
"0.52848774",
"0.5271975",
"0.52656025",
"0.5260177",
"0.5256466",
"0.5241006",
"0.52377856",
"0.5237103",
"0.5233109",
"0.52077115",
"0.5207379",
"0.5207379",
"0.52006495",
"0.51963955",
"0.5194937",
"0.51887745",
"0.5177633",
"0.5174224",
"0.5168835",
"0.51683015",
"0.51614285",
"0.5161338",
"0.5159999",
"0.51559794",
"0.51527107",
"0.5152299",
"0.5151062",
"0.51500124",
"0.5144919",
"0.5143687",
"0.5141471",
"0.5138298",
"0.5134005",
"0.5132179",
"0.5123837",
"0.5121418",
"0.5116173",
"0.51156825",
"0.51068336",
"0.5106134",
"0.5104789",
"0.509977",
"0.50935394",
"0.5092784",
"0.5086892",
"0.50865763",
"0.50822455",
"0.5081028",
"0.50800776",
"0.50796247",
"0.5071398",
"0.50645566",
"0.50634426",
"0.50629807",
"0.50616056",
"0.50572044",
"0.5056564",
"0.50473875",
"0.50468546",
"0.5040437",
"0.5039536",
"0.5039517"
] |
0.69906765
|
2
|
DELETE /extractions_extraction_forms_projects_sections_type1/1 DELETE /extractions_extraction_forms_projects_sections_type1/1.json
|
def destroy
@extractions_extraction_forms_projects_sections_type1.destroy
respond_to do |format|
format.html do
redirect_to work_extraction_path(@extractions_extraction_forms_projects_sections_type1
.extractions_extraction_forms_projects_section
.extraction,
'panel-tab': @extractions_extraction_forms_projects_sections_type1
.extractions_extraction_forms_projects_section
.extraction_forms_projects_section
.id),
notice: t('removed')
end
format.json { head :no_content }
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def destroy\n @extractions_extraction_forms_projects_sections_type1.destroy\n respond_to do |format|\n format.html { redirect_to work_extraction_path(@extractions_extraction_forms_projects_sections_type1\n .extractions_extraction_forms_projects_section\n .extraction,\n anchor: \"panel-tab-#{ @extractions_extraction_forms_projects_sections_type1\n .extractions_extraction_forms_projects_section.id }\"),\n notice: t('removed') }\n format.json { head :no_content }\n end\n end",
"def destroy\n authorize(@extraction)\n\n @extraction.destroy\n respond_to do |format|\n format.html do\n redirect_to project_extractions_url(@extraction.project), notice: 'Extraction was successfully destroyed.'\n end\n format.json { head :no_content }\n end\n end",
"def destroy\n @domicile_type_section = DomicileTypeSection.find(params[:id])\n @domicile_type_section.destroy\n\n respond_to do |format|\n format.html { redirect_to(domicile_type_sections_url) }\n format.xml { head :ok }\n end\n end",
"def test_delete_section_fields\n local_file_name = 'test_multi_pages.docx'\n remote_file_name = 'TestDeleteSectionFields.docx'\n\n upload_file File.join(local_test_folder, 'Common/' + local_file_name), remote_data_folder + '/' + remote_file_name\n\n request = DeleteFieldsRequest.new(name: remote_file_name, node_path: 'sections/0', folder: remote_data_folder)\n\n @words_api.delete_fields(request)\n end",
"def destroy\n @section.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @ref_diagnostic_test_type = Ref::DiagnosticTestType.find(params[:id])\n @ref_diagnostic_test_type.destroy\n\n respond_to do |format|\n format.html { redirect_to ref_diagnostic_test_types_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @ref_med_diagnostic_test_type = Ref::MedDiagnosticTestType.find(params[:id])\n @ref_med_diagnostic_test_type.destroy\n\n respond_to do |format|\n format.html { redirect_to ref_med_diagnostic_test_types_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @education_service_provided_typology.destroy\n respond_to do |format|\n format.html { redirect_to education_service_provided_typologies_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @defect_type.destroy\n respond_to do |format|\n format.html { redirect_to defect_types_url, notice: 'Defect type was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n story_part_id = @story_part.id\n @story_part.destroy\n render :json => story_part_id\n end",
"def destroy\n hydralic_type = @hydralic_particular.hydralic_type\n @hydralic_particular.destroy\n respond_to do |format|\n format.html { redirect_to project_sub_project_hydralic_particulars_path(@project, @sub_project, :hydralic_type => hydralic_type), notice: 'Hydralic particular was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete_course_template(org_unit_id)\n path = \"/d2l/api/lp/#{$lp_ver}/coursetemplates/#{org_unit_id}\"\n _delete(path)\n puts '[+] Course template data deleted successfully'.green\nend",
"def destroy\n @research.destroy\n respond_to do |format|\n format.html { redirect_to menu_investigacion_3_path, notice: 'La actividad se elimino con exito.' }\n format.json { head :no_content }\n end\n\n end",
"def destroy\n @section.destroy\n respond_to do |format|\n form_wrapper = FormWrapper.find(@section.form_wrapper_id)\n format.html { redirect_to sections_section_path(form_wrapper), alert: I18n.t('activerecord.models.section.single') + I18n.t('helpers_locale.models.created') }\n format.json { head :no_content }\n end\n end",
"def destroy\n @featured_project.destroy\n respond_to do |format|\n format.json { head :no_content }\n end\n end",
"def destroy\n @doc_type.destroy\n respond_to do |format|\n format.html { redirect_to doc_types_url, notice: t('message.template.scaffold.destroy', model: t('activerecord.models.doc_type')) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @section_heading = SectionHeading.find(params[:id])\n @section_heading.destroy\n\n respond_to do |format|\n format.html { redirect_to section_headings_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @section_test = SectionTest.find(params[:id])\n @section_test.destroy\n\n respond_to do |format|\n format.html { redirect_to section_tests_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @step_type = StepType.find(params[:id])\n @step_type.destroy\n\n respond_to do |format|\n format.html { redirect_to step_types_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @foundation_type.destroy\n respond_to do |format|\n format.html { redirect_to foundation_types_url, notice: 'Foundation type was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @lab_section.destroy\n respond_to do |format|\n format.html { redirect_to lab_sections_url, notice: 'Lab section was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @three60.destroy\n respond_to do |format|\n format.html { redirect_to edit_admin_good_url(@good, anchor: \"three60\") }\n format.json { head :no_content }\n end\n end",
"def test_delete_section_paragraph_fields\n local_file_name = 'test_multi_pages.docx'\n remote_file_name = 'TestDeleteSectionParagraphFields.docx'\n\n upload_file File.join(local_test_folder, 'Common/' + local_file_name), remote_data_folder + '/' + remote_file_name\n\n request = DeleteFieldsRequest.new(name: remote_file_name, node_path: 'sections/0/paragraphs/0', folder: remote_data_folder)\n\n @words_api.delete_fields(request)\n end",
"def destroy\n @fieldtype = Fieldtype.find(params[:id])\n @fieldtype.destroy\n\n respond_to do |format|\n format.html { redirect_to fieldtypes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @sectioneight_form = SectioneightForm.find(params[:id])\n @sectioneight_form.destroy\n\n respond_to do |format|\n format.html { redirect_to sectioneight_forms_url }\n format.json { head :no_content }\n end\n end",
"def delete_analysis(analysis_id); rest_delete(\"#{link('analyses')}/#{analysis_id}\"); nil; end",
"def destroy\n @all_field_type = AllFieldType.find(params[:id])\n @all_field_type.destroy\n\n respond_to do |format|\n format.html { redirect_to all_field_types_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n # http://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Delete+or+destroy-3F\n # @transect.transect_admin_editor.each(&:destroy)\n @transect.tree_plots.each(&:destroy)\n @transect.destroy\n respond_to do |format|\n format.html { redirect_to transects_url, notice: 'Transect was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n project = @specification.project\n @specification.destroy\n respond_to do |format|\n format.html { redirect_to project_path(project) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @project_phase = ProjectPhase.find(params[:id])\n @project_phase.destroy\n\n respond_to do |format|\n format.html { redirect_to project_phases_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @example_section = ExampleSection.find(params[:id])\n @example_section.destroy\n\n respond_to do |format|\n format.html { redirect_to(example_sections_url) }\n format.xml { head :ok }\n end\n end",
"def destroy\n @partextra.destroy\n respond_to do |format|\n format.html { redirect_to extras_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @flat_type.destroy\n respond_to do |format|\n format.html { redirect_to flat_types_url, notice: 'Flat type was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @coverage_type.destroy\n respond_to do |format|\n format.html { redirect_to coverage_types_url, notice: 'Coverage type was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def DeleteField id\n \n APICall(path: \"ticket_fields/#{id}.json\",method: 'DELETE')\n \n end",
"def destroy\n @project_area_interest.destroy\n respond_to do |format|\n format.html { redirect_to project_area_interests_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @applicant_field_of_study.destroy\n respond_to do |format|\n format.html { redirect_to applicant_field_of_studies_url, notice: 'Applicant field of study was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @step_definition.destroy\n respond_to do |format|\n format.html { redirect_to step_definitions_url, notice: 'Step definition was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @typetutorial.destroy\n respond_to do |format|\n format.html { redirect_to typetutorials_url, notice: 'Typetutorial was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\r\n @theoretical_part = TheoreticalPart.find(params[:id])\r\n @theoretical_part.destroy\r\n\r\n respond_to do |format|\r\n format.html { redirect_to theoretical_parts_url }\r\n format.json { head :no_content }\r\n end\r\n end",
"def test_del\n header 'Content-Type', 'application/json'\n\n data = File.read 'sample-traces/0.json'\n post('/traces', data, 'CONTENT_TYPE': 'application/json')\n\n id = last_response.body\n\n delete \"/traces/#{id}\"\n assert last_response.ok?\n\n get \"/traces/#{id}\"\n\n contents = JSON.parse last_response.body\n assert_kind_of(Hash, contents, 'Response contents is not a hash')\n assert contents.key? 'description'\n assert(!last_response.ok?)\n end",
"def destroy\n @reflection.destroy\n respond_to do |format|\n format.html { redirect_to reflections_url, notice: 'Reflection was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @reflection = Reflection.find(params[:id])\n @reflection.destroy\n\n respond_to do |format|\n format.html { redirect_to reflections_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @section.destroy\n respond_to do |format|\n format.html { redirect_to sections_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @section.destroy\n respond_to do |format|\n format.html { redirect_to sections_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @complexity = Complexity.find(params[:id])\n @complexity.destroy\n\n respond_to do |format|\n format.html { redirect_to complexities_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @subpart.destroy\n respond_to do |format|\n format.html { redirect_to subparts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @project_type.destroy\n respond_to do |format|\n format.html { redirect_to project_types_url, notice: 'Project type was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @bridge_project_typology.destroy\n respond_to do |format|\n format.html { redirect_to bridge_project_typologies_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @type_project.destroy\n respond_to do |format|\n format.html { redirect_to type_projects_url, notice: 'Type project was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @step_three.destroy\n respond_to do |format|\n format.html { redirect_to step_threes_url, notice: 'Step three was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @court_complex.destroy\n respond_to do |format|\n format.html { redirect_to court_complexes_url, notice: 'Court complex was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @project_step_m.destroy\n respond_to do |format|\n format.html { redirect_to project_step_ms_url, notice: 'Project step m was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @home = Home.first\n @about = About.first\n \n @section = Section.find(params[:id])\n \n @section.destroy\n respond_to do |format|\n format.html { redirect_to admin_sections_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @property_toilet_artifact.destroy\n respond_to do |format|\n format.html { redirect_to property_toilet_artifacts_url, notice: 'Property toilet artifact was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @content.destroy\n respond_to do |format|\n format.html { redirect_to project_content_type_contents_path(@project, @content_type) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @reflection.destroy\n head :no_content\n end",
"def destroy\n @liquidation_form_line.destroy\n respond_to do |format|\n format.html { redirect_to liquidation_form_lines_url, notice: 'Liquidation form line was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @project_step.destroy\n respond_to do |format|\n format.html { redirect_to project_steps_url, notice: 'Project step was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @project_type_workflow.destroy\n respond_to do |format|\n format.html { redirect_to project_type_workflows_url, notice: 'Project type workflow was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @farm_practice_typology.destroy\n respond_to do |format|\n format.html { redirect_to farm_practice_typologies_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @recreation_service_typology.destroy\n respond_to do |format|\n format.html { redirect_to recreation_service_typologies_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @ref_hospitalization_type = Ref::HospitalizationType.find(params[:id])\n @ref_hospitalization_type.destroy\n\n respond_to do |format|\n format.html { redirect_to ref_hospitalization_types_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @researcharea = Researcharea.find(params[:id])\n @researcharea.destroy\n\n respond_to do |format|\n format.html { redirect_to researchareas_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @part_three_predict = PartThreePredict.find(params[:id])\n @part_three_predict.destroy\n\n respond_to do |format|\n format.html { redirect_to part_three_predicts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @tool_type.destroy\n respond_to do |format|\n format.html { redirect_to tool_types_url }\n format.json { head :no_content }\n end\n end",
"def destroy \n @step = Step.find(params[:id])\n @step.destroy\n\n respond_to do |format|\n format.html { redirect_to selection_path(params[:selection_id]) }\n format.json { head :no_content }\n end\n end",
"def destroy\n @intervention_type.destroy\n respond_to do |format|\n format.html { redirect_to intervention_types_url, notice: 'O tipo de intervenção foi eliminado.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @flat.destroy\n\n respond_to do |format|\n format.html { redirect_to flats_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @singlepart.destroy\n respond_to do |format|\n format.html { redirect_to singleparts_url, notice: 'Singlepart was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @tutorial_section.destroy\n respond_to do |format|\n format.html { redirect_to tutorial_sections_url, notice: 'Tutorial section was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @structure_drawing.destroy\n respond_to do |format|\n format.html { redirect_to project_sub_project_structure_drawings_path(@project, @sub_project), notice: 'Structure drawing was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @projectile_type.destroy\n respond_to do |format|\n format.html { redirect_to projectile_types_url, notice: 'Projectile type was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @examination.destroy\n\n respond_to do |format|\n format.html { redirect_to @examination.project }\n format.json { head :no_content }\n end\n end",
"def destroy\n @protein_complex = ProteinComplex.find(params[:id])\n @protein_complex.destroy\n\n respond_to do |format|\n format.html { redirect_to protein_complexes_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @formulary = Formulary.find(params[:id])\n @formulary.destroy\n\n respond_to do |format|\n format.html { redirect_to formularies_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @archetype = Archetype.find(params[:id])\n @archetype.destroy\n\n respond_to do |format|\n format.html { redirect_to archetypes_url }\n format.json { head :no_content }\n end\n end",
"def delete(path_part, additional_headers = {}, &block)\n api_request { @rest.delete('/REST/' + path_part, \"\", additional_headers, &block) }\n end",
"def destroy\n @project_type.destroy\n respond_to do |format|\n format.html { redirect_to base_project_types_url, notice: 'Base project type was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @line_detail.destroy\n respond_to do |format|\n format.html { redirect_to line_details_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @import_def = ImportDef.find(params[:id])\n @import_def.destroy\n\n respond_to do |format|\n format.html { redirect_to import_defs_url }\n format.json { head :ok }\n end\n end",
"def destroy\n @interview_type.destroy\n respond_to do |format|\n format.html { redirect_to interview_types_url, notice: 'Interview type was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @inspection_template.destroy\n respond_to do |format|\n format.html { redirect_to inspection_templates_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @tc_detail_step = TcDetailStep.find(params[:id])\n @tc_detail_step.destroy\n\n respond_to do |format|\n format.html { redirect_to tc_detail_steps_url }\n format.json { head :no_content }\n end\n end",
"def _delete(type, *args)\n type = type.to_s.camelize\n metadata = args.map { |full_name| {:full_name => full_name} }\n request :delete do |soap|\n soap.body = {\n :metadata => metadata\n }.merge(attributes!(type))\n end\n end",
"def destroy\n @studytype.destroy\n respond_to do |format|\n format.html { redirect_to moderator_studytypes_url, notice: 'Studytype was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @arc_type.destroy\n respond_to do |format|\n format.html { redirect_to arc_types_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @testtype.destroy\n respond_to do |format|\n format.html { redirect_to testtypes_url }\n format.json { head :no_content }\n end\n end",
"def delete_from_entzumena\n headline = Headline.where({:source_item_type => params[:source_item_type], :source_item_id => params[:source_item_id]}).first\n if headline.destroy\n render :json => true, :status => 200\n else\n render :json => false, :status => :error\n end\n end",
"def test_delete_section_fields_without_node_path\n local_file_name = 'test_multi_pages.docx'\n remote_file_name = 'TestDeleteSectionFieldsWithoutNodePath.docx'\n\n upload_file File.join(local_test_folder, 'Common/' + local_file_name), remote_data_folder + '/' + remote_file_name\n\n request = DeleteFieldsRequest.new(name: remote_file_name, folder: remote_data_folder)\n\n @words_api.delete_fields(request)\n end",
"def destroy\n @field_definition.destroy\n respond_to do |format|\n format.html { redirect_to field_definitions_url, notice: 'Field definition was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @type_expertise = TypeExpertise.find(params[:id])\n @type_expertise.destroy\n\n\n respond_to do |format|\n format.html { redirect_to(type_expertises_url) }\n format.xml { head :ok }\n format.json {render :json => {\"success\"=>true,\"data\"=>[]}}\n end\n end",
"def destroy\n @divition_type.destroy\n respond_to do |format|\n format.html { redirect_to divition_types_url, notice: 'Divition type was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @callout.destroy\n respond_to do |format|\n format.html { redirect_to callouts_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @image_section = ImageSection.find(params[:id])\n @image_section.destroy\n\n respond_to do |format|\n format.html { redirect_to image_sections_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @so_header = SoHeader.find(params[:so_header_id])\n @so_line = @so_header.so_lines.find(params[:id])\n @so_line.destroy\n\n respond_to do |format|\n format.html { redirect_to so_header_so_lines_url(@so_header) }\n format.json { head :ok }\n end\n end",
"def destroy\n @section_heading.destroy\n respond_to do |format|\n format.html { redirect_to section_headings_url, notice: 'Section heading was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def destroy\n @make_section = MakeSection.find(params[:id])\n @make_section.destroy\n\n respond_to do |format|\n format.html { redirect_to(make_sections_url) }\n format.xml { head :ok }\n end\n \n end",
"def destroy\n @survey_section.destroy\n respond_to do |format|\n format.html { redirect_to survey_sections_url, notice: 'Survey section was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def test_delete_document_fields\n local_file_name = 'test_multi_pages.docx'\n remote_file_name = 'TestDeleteSectionParagraphFields.docx'\n\n upload_file File.join(local_test_folder, 'Common/' + local_file_name), remote_data_folder + '/' + remote_file_name\n\n request = DeleteFieldsRequest.new(name: remote_file_name, node_path: '', folder: remote_data_folder)\n\n @words_api.delete_fields(request)\n end"
] |
[
"0.7626632",
"0.6354295",
"0.63228387",
"0.63028866",
"0.62969583",
"0.6292912",
"0.62236863",
"0.62202066",
"0.62114114",
"0.61981344",
"0.6196551",
"0.61782646",
"0.6177106",
"0.6175349",
"0.6148747",
"0.6143146",
"0.61424005",
"0.6111107",
"0.61093783",
"0.6106999",
"0.61065483",
"0.61057365",
"0.6081088",
"0.60718185",
"0.60716623",
"0.606185",
"0.60614145",
"0.6052431",
"0.604945",
"0.6043932",
"0.60374224",
"0.60359514",
"0.6026934",
"0.60231483",
"0.60204756",
"0.60201836",
"0.60188293",
"0.6014161",
"0.60023195",
"0.6001018",
"0.6000663",
"0.59982383",
"0.5997028",
"0.5986541",
"0.5986541",
"0.59855694",
"0.5974593",
"0.59745485",
"0.5968995",
"0.59686536",
"0.59655523",
"0.5965246",
"0.5964917",
"0.59635407",
"0.5962213",
"0.59603673",
"0.5960041",
"0.5955548",
"0.5955418",
"0.59472895",
"0.59443796",
"0.59419024",
"0.59384245",
"0.5937803",
"0.5936417",
"0.59358543",
"0.59330773",
"0.59321654",
"0.5931022",
"0.59302825",
"0.59227955",
"0.5920144",
"0.59195364",
"0.59159666",
"0.5915317",
"0.5914253",
"0.590957",
"0.59094",
"0.59092057",
"0.5908321",
"0.59069806",
"0.5905595",
"0.5905549",
"0.59051347",
"0.59048027",
"0.5900678",
"0.589787",
"0.58976054",
"0.5896606",
"0.5896213",
"0.589383",
"0.58936805",
"0.5892814",
"0.5892434",
"0.58913183",
"0.58905244",
"0.5883895",
"0.58811843",
"0.5880482",
"0.5878196"
] |
0.76073885
|
1
|
POST /extractions_extraction_forms_projects_sections_type1s/1/add_population POST /extractions_extraction_forms_projects_sections_type1s/1/add_population.json
|
def add_population
authorize(@extractions_extraction_forms_projects_sections_type1)
@extractions_extraction_forms_projects_sections_type1.extractions_extraction_forms_projects_sections_type1_rows.each do |eefpst1r|
eefpst1r.extractions_extraction_forms_projects_sections_type1_row_columns.create
end
redirect_to(
edit_populations_extractions_extraction_forms_projects_sections_type1(@extractions_extraction_forms_projects_sections_type1),
notice: t('success'),
status: 303
)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def add_population\n @extractions_extraction_forms_projects_sections_type1.extractions_extraction_forms_projects_sections_type1_rows.each do |eefpst1r|\n eefpst1r.extractions_extraction_forms_projects_sections_type1_row_columns.create\n end\n\n redirect_to edit_populations_extractions_extraction_forms_projects_sections_type1(@extractions_extraction_forms_projects_sections_type1), notice: t('success')\n end",
"def create\n @population = Population.new(population_params)\n\n respond_to do |format|\n if @population.save\n format.html { redirect_to @population, notice: 'Population was successfully created.' }\n format.json { render :show, status: :created, location: @population }\n else\n format.html { render :new }\n format.json { render json: @population.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @stage_population = StagePopulation.new(params[:stage_population])\n\n respond_to do |format|\n if @stage_population.save\n format.html { redirect_to @stage_population, notice: 'Stage population was successfully created.' }\n format.json { render json: @stage_population, status: :created, location: @stage_population }\n else\n format.html { render action: \"new\" }\n format.json { render json: @stage_population.errors, status: :unprocessable_entity }\n end\n end\n end",
"def population_params\n params.require(:population).permit(:type_population, :age_init, :age_end)\n end",
"def population_params\n params.require(:population).permit(:year, :country, :continent, :population, :rank)\n end",
"def set_population\n @population = Population.find(params[:id])\n end",
"def set_population\n @population = Population.find(params[:id])\n end",
"def create\n @barangay_population = BarangayPopulation.new(barangay_population_params)\n\n respond_to do |format|\n if @barangay_population.save\n format.html { redirect_to @barangay_population, notice: 'Barangay population was successfully created.' }\n format.json { render action: 'show', status: :created, location: @barangay_population }\n else\n format.html { render action: 'new' }\n format.json { render json: @barangay_population.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @neural_population = NeuralPopulation.new(params[:neural_population])\n @quote_targets = QuoteTarget.find(:all)\n @neural_population.quote_target_id = params[:quote_target_id]\n respond_to do |format|\n if @neural_population.save\n @neural_population.initialize_population\n @neural_population.active = 1\n @neural_population.save\n flash[:notice] = 'NeuralPopulation was successfully created.'\n format.html { redirect_to(@neural_population) }\n format.xml { render :xml => @neural_population, :status => :created, :location => @neural_population }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @neural_population.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @regulation = Regulation.new(params[:regulation])\n\n respond_to do |format|\n if @regulation.save\n format.html { redirect_to @regulation, notice: 'Regulation was successfully created.' }\n format.json { render json: @regulation, status: :created, location: @regulation }\n else\n format.html { render action: \"new\" }\n format.json { render json: @regulation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def new\n @stage_population = StagePopulation.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @stage_population }\n end\n end",
"def add_individual_to_house\n\t\tindividual = Individual.create!(:name => params[:individual_name])\n\t\t@house = House.find(params[:house_id])\n\t\t@house.individuals << individual\n\t\trender :update do |page|\n\t\t\tpage.replace_html 'individuals_detail', :partial => 'individuals', :object => @house.individuals, :locals => {:house_id => @house.id}\n\t\t\tpage.visual_effect :highlight, \"individual_id_#{individual.id}\"\n\t\tend\n\tend",
"def add_population(uk)\n total_pop = 0\n\n for population in uk\n total_pop += population[:population]\n end\n return total_pop\n # remember to put return outside the loop!\n end",
"def create\n\trespond_to do |format|\n\t\tDesignDetailDataPoint.save_data_point_info(session[:study_id], params)\n\t\t#DesignDetailDataPoint.save_data_point_totals(session[:study_id], params)\n\t format.js {\n\t\t\t \trender :update do |page|\n\t\t\t\t\t\tpage.replace_html 'population_characteristic_validation_message', \"Saved\"\n\t\t\t \tend\n\t\t\t\t}\t\t\n\tend\n end",
"def add_element_to_section(section,type,data)\n url = @base + \"elements.json\"\n params = {\"item\"=>{\"element_type\"=> type, \"data\"=>data, \"container_type\"=>\"ExperimentProcedure\", \"container_id\"=>section[\"id\"], \"field_name\"=>section[\"section_type\"]},token: @token}\n response = JSON.parse(RestClient.post(url,params))\nend",
"def incPopulation(n)\n @population += n ;\n end",
"def add!(p)\n raise Exception.new(\"Object is not a Population or PopulationGroup\") if !p.is_a?(Population) && !p.is_a?(PopulationGroup)\n population_group_members.find_or_create_by_population_groupable_type_and_population_groupable_id(p.class.to_s, p.id)\n end",
"def given_population(&block)\n @populations.push(Population.new(&block))\n end",
"def create\n\n @expense = Expense.new(expense_params)\n\n b_id = Building.search(@expense.buildinginfo)\n Building.find_by(id: b_id).expenses << @expense\n \n respond_to do |format|\n if @expense.save\n format.html { redirect_to @expense, notice: 'Expense was successfully created.' }\n format.json { render :show, status: :created, location: @expense }\n else\n format.html { render :new }\n format.json { render json: @expense.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @laboratory = Laboratory.new(params[:laboratory])\n @municipalities = Municipality.all\n respond_to do |format|\n if @laboratory.save\n format.html { redirect_to @laboratory, notice: 'Laboratory was successfully created.' }\n format.json { render json: @laboratory, status: :created, location: @laboratory }\n else\n format.html { render action: \"new\" }\n format.json { render json: @laboratory.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n load_arrays_for_create\n @expenditure = Expenditure.new(expenditure_params)\n\n respond_to do |format|\n if @expenditure.save\n format.html { redirect_to expenditures_path, notice: 'Expenditure was successfully created.' }\n format.json { render :show, status: :created, location: @expenditure }\n else\n format.html { render :new }\n format.json { render json: @expenditure.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @popularty = Popularty.new(params[:popularty])\n\n respond_to do |format|\n if @popularty.save\n format.html { redirect_to @popularty, notice: 'Popularty was successfully created.' }\n format.json { render json: @popularty, status: :created, location: @popularty }\n else\n format.html { render action: \"new\" }\n format.json { render json: @popularty.errors, status: :unprocessable_entity }\n end\n end\n end",
"def population\n @populations.first\n end",
"def add_generic\n\t\temp = getMyEnterpriseAPP\n\t\tdim = params[:dimension]\n\t\t# ES: La dimension puede venir en español o en ingles, verifica y ajusta (En la BD SIEMPRE EN ESPAÑOL!)\n\t\t# EN: The dimension could be in spanish or english, verify and adjust it (In the DB ALWAYS IN SPANISH!)\n\t\tif !I18n.default_locale.to_s.eql?(\"es\")\n\t\t\t# ES: Viene en ingles, debe pasarla a español:\n\t\t\t# EN: English, must translate it:\n\t\t\tdim = view_context.translateDimensionToES(dim)\n\t\tend\n\t\t\n\t\tdesc = params[:description]\n\t\t# ES: Crea una decision generica:\n\t\t# EN: Creates a generic decision:\n\t\tdecGen = GovernanceDecision.new\n\t\tdecGen.description = desc\n\t\tdecGen.dimension = dim\n\t\tdecGen.decision_type = GENERIC_TYPE\n\t\tdecGen.enterprise_id = emp.id\n\n\t\trespond_to do |format|\n\t\t\tif decGen.save\n\t\t\t\t# OK\n\t\t\t\tformat.json {render json: decGen}\n\t\t\telse\n\t\t\t\t# ES: No se pudo guardar\n\t\t\t\t# EN: Couldn't save\n\t\t\t\tformat.json {render json: 'ERROR'}\n\t\t\tend\n\t\t\t\n end\t\n\tend",
"def create\n @gen_attraction = GenPackage.find_by_name(params[:city]).gen_attractions.build(name: \"Test\")\n\n respond_to do |format|\n if @gen_attraction.save\n format.html { redirect_to gen_attractions_path, notice: 'Gen attraction was successfully created.' }\n format.json { render :show, status: :created, location: gen_attractions_path }\n else\n format.html { render :new }\n format.json { render json: gen_attractions_path.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_element_to_section(section,type,data)\n url = @base + \"/api/v1/elements.json\"\n params = {\"item\"=>{\"element_type\"=> type, \"data\"=>data, \"container_type\"=>\"ExperimentProcedure\", \"container_id\"=>section[\"id\"], \"field_name\"=>section[\"section_type\"]},token: @token}\n response = JSON.parse(RestClient.post(url,params))\nend",
"def create\n @work = Work.new(params[:work].except(:extra_keys, :extra_values))\n @work.extra = process_extra if params[:extra_keys]\n \n current_dataset.works << @work\n \n Work.create_locations(@work) if @work.places\n\n respond_to do |format|\n if @work.save\n format.html { redirect_to @work, notice: 'Work was successfully created.' }\n format.json { render json: @work, status: :created, location: @work }\n else\n format.html { render action: \"new\" }\n format.json { render json: @work.errors, status: :unprocessable_entity }\n end\n end\n end",
"def extractions_extraction_forms_projects_sections_type1_params\n params.require(:extractions_extraction_forms_projects_sections_type1)\n .permit(:type1_type_id, :extractions_extraction_forms_projects_section_id, :type1_id, :units,\n should: :propagate,\n type1_attributes: %i[id name description],\n extractions_extraction_forms_projects_sections_type1_rows_attributes: [\n :id, :_destroy,\n { population_name_attributes: %i[id name description],\n extractions_extraction_forms_projects_sections_type1_row_columns_attributes: [\n :id, :_destroy,\n { timepoint_name_attributes: %i[id name unit] }\n ] }\n ])\n end",
"def new\n @population = Population.new(:access_level => 'creator')\n session[:breadcrumbs].add \"New\"\n\n respond_to do |format|\n format.html # new.html.erb\n format.xml { render :xml => @population }\n end\n end",
"def update\n respond_to do |format|\n if @population.update(population_params)\n format.html { redirect_to @population, notice: 'Population was successfully updated.' }\n format.json { render :show, status: :ok, location: @population }\n else\n format.html { render :edit }\n format.json { render json: @population.errors, status: :unprocessable_entity }\n end\n end\n end",
"def population(starting_set)\n starting_set = starting_set.to_s if starting_set.is_a?(Symbol)\n p = Population.find_or_initialize_by_populatable_type_and_populatable_id_and_starting_set_and_conditions_counter(\n \"Offering\", self.id, starting_set, 0)\n if p.new_record?\n p.title = \"#{self.title}: #{starting_set.titleize}\"\n until p.valid? && !p.errors.on(:title)\n if p.title[/\\d+$/].nil?\n p.title += \" 2\"\n else\n new_num = p.title[/\\d+$/].to_i + 1\n p.title.gsub!(/\\d+$/, new_num.to_s)\n end\n end \n p.system = true\n p.description = \"Automatically generated by Offering ##{self.id} from starting set '#{starting_set}'\"\n p.access_level = \"everyone\"\n p.save\n end\n p\n end",
"def create\n visit(CentralAdmin).create_institutional_proposal\n on ProposalLogLookup do |look|\n look.proposal_number.set @proposal_number\n look.search\n look.select_item @proposal_number\n end\n on InstitutionalProposal do |create|\n create.expand_all\n @document_id=create.document_id\n @doc_header=create.doc_title\n @proposal_number=create.institutional_proposal_number\n fill_out create, :proposal_type, :award_id, :activity_type, :project_title, :description\n set_sponsor_code\n create.save\n end\n if @proposal_log && $current_page.errors.size==0\n pi = make ProjectPersonnelObject, principal_name: @proposal_log.principal_investigator,\n full_name: @proposal_log.pi_full_name,\n document_id: @document_id,\n lookup_class: @lookup_class,\n search_key: @search_key,\n doc_header: @doc_header\n @project_personnel << pi\n view :contacts\n @project_personnel.principal_investigator.set_up_units\n end\n end",
"def create\n @proj_insp = ProjInsp.new(proj_insp_params)\n\n respond_to do |format|\n if @proj_insp.save\n format.html { redirect_to @proj_insp, notice: 'Project inspection was successfully created.' }\n format.json { render :show, status: :created, location: @proj_insp }\n else\n format.html { render :new }\n format.json { render json: @proj_insp.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_new_area\n self.button(:id=>\"group_create_new_area\", :class=>\"s3d-button s3d-header-button s3d-popout-button\").click\n wait_for_ajax\n self.class.class_eval { include AddAreasPopUp }\n end",
"def add\n\t\tquest = Quest.new\n\t\tquest.name = params[:name]\n\t\tquest.address = params[:address]\n\t\tquest.hint = params[:hint]\n\t\tquest.brief = params[:brief]\n\t\tquest.latitude = params[:latitude] || 0\n\t\tquest.latitude = quest.latitude.to_d\n\t\tquest.longitude = params[:longitude] || 0\n\t\tquest.longitude = quest.longitude.to_d\n\t\tquest.difficulty = params[:difficulty] || 0\n\t\tquest.difficulty = quest.difficulty.to_i\t\n\t\tquest.place_name = params[:place_name]\n\t\tquest.phone = params[:phone]\n\t\tquest.fun_facts = params[:fun_facts]\n\t\t\n\t\tif quest.save\n\t\t\trender json: quest, root: true\n\t\telse\n\t\t\trender json: {error: \"could not add quest\"}\n\t\tend\n\tend",
"def add_specific\n\t\t@empresa = getMyEnterpriseAPP\n\t\tpadre = GovernanceDecision.find(params[:id_padre].to_i)\n\t\t# ES: Parametros para construir la decision:\n\t\t# EN: Parameters to build a new decisions:\n\t\tdesc = params[:description]\n\t\tdim = padre.dimension\n\t\t# ES: Crea la decision:\n\t\t# EN: Creates the decision:\n\t\tdecSpe = GovernanceDecision.new\n\t\tdecSpe.description = desc\n\t\tdecSpe.dimension = padre.dimension\n\t\tdecSpe.decision_type = SPECIFIC_TYPE\n\t\tdecSpe.parent_id = padre.id\n\t\tdecSpe.enterprise_id = @empresa.id\n\n\t\trespond_to do |format|\n\t\t\tif decSpe.save\n\t\t\t\t# OK\n\t\t\t\tformat.json {render json: decSpe}\n\t\t\telse\n\t\t\t\t# ES: No se pudo guardar\n\t\t\t\t# EN: Couldn't save\n\t\t\t\tformat.json {render json: 'ERROR'}\n\t\t\tend\n\t\t\t\n end\n\tend",
"def add_section(project_id, data = {})\n post(\"add_section/#{project_id}\", body: data.to_json)\n end",
"def create_investments investment_type\n self.create_investment_type(:fix_income => investment_type[:fix_income], :equity=> investment_type[:equity], :gold=> investment_type[:gold], :land_and_estate=> investment_type[:land_and_estate])\n end",
"def index\n @populations = Population.all\n end",
"def create\n @fraction = Fraction.new(params[:fraction])\n\n @municipality = @fraction.municipality\n\n respond_to do |format|\n if @fraction.save\n format.html { redirect_to @municipality, notice: 'Fraction was successfully created.' }\n format.json { render json: @fraction, status: :created, location: @fraction }\n else\n format.html { render action: \"new\" }\n format.json { render json: @fraction.errors, status: :unprocessable_entity }\n end\n end\n end",
"def population_name_attributes=(attributes)\n ExtractionsExtractionFormsProjectsSectionsType1Row.transaction do\n attributes.delete(:id) # Remove ID from hash since this may carry the ID of\n # the object we are trying to change.\n self.population_name = PopulationName.find_or_create_by!(attributes)\n attributes[:id] = population_name.id # Need to put this back in, otherwise rails will\n # try to create this record, since its ID is\n # missing and it assumes it's a new item.\n end\n super\n end",
"def create\n @proposal=Proposal.find(params[:id])\n @geographic_coverage = GeographicCoverage.new(geographic_coverage_params)\n ssssadasd asd as\n respond_to do |format|\n if @geographic_coverage.save\n format.html { redirect_to edit_proposal_path(params[:id]), notice: 'Geographic coverage was successfully created.' }\n format.json { render :show, status: :created, location: @geographic_coverage }\n format.js\n else\n format.html { render :new }\n format.json { render json: @geographic_coverage.errors, status: :unprocessable_entity }\n end\n end\n end",
"def setup_population\n destroy_data\n reindex\n @total_pages = nil\n @pages_retrieved = 0\n end",
"def create\n @enhancement = Enhancement.new(params[:enhancement])\n\n respond_to do |format|\n if @enhancement.save\n format.html { redirect_to @enhancement, notice: 'Enhancement was successfully created.' }\n format.json { render json: @enhancement, status: :created, location: @enhancement }\n else\n format.html { render action: \"new\" }\n format.json { render json: @enhancement.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @pop_element = PopElement.new(pop_element_params)\n\n respond_to do |format|\n if @pop_element.save\n format.html { redirect_to @pop_element, notice: 'Pop element was successfully created.' }\n format.json { render :show, status: :created, location: @pop_element }\n else\n format.html { render :new }\n format.json { render json: @pop_element.errors, status: :unprocessable_entity }\n end\n end\n end",
"def congregation_params\n params.require(:congregation).permit(:population_id, :deity_id, :clergy, :laity, :piety_multiplier, :manpower_multiplier, :loyalty)\n end",
"def create\n @graphic = Graphic.new(params[:graphic])\n @page_section = @graphic.build_page_section(params[:page_section])\n \n @page = @page_section.page\n @site_section = @page.site_section\n\n respond_to do |format|\n if @graphic.save\n flash[:notice] = 'Graphic was successfully created.'\n format.html { redirect_to site_section_page_url(@site_section, @page) }\n format.xml { render :xml => @graphic, :status => :created, :location => @graphic }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @graphic.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def addAgent(agent)\n# @agentList.push(agent) ;\n# @population = @agentList.length ;\n incPopulation(1) ;\n end",
"def create\n @privilieges_feature = PriviliegesFeature.new(privilieges_feature_params)\n\n respond_to do |format|\n if @privilieges_feature.save\n format.html { redirect_to @privilieges_feature, notice: 'Privilieges feature was successfully created.' }\n format.json { render :show, status: :created, location: @privilieges_feature }\n else\n format.html { render :new }\n format.json { render json: @privilieges_feature.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n count = person_equipment_params[:count].to_i\n params = person_equipment_params.merge(count: 1)\n @person_equipments = []\n count.times do |i|\n @person_equipments << PersonEquipment.new(params)\n end\n @person_equipments.each(&:save)\n respond_to do |format|\n if @person_equipments.last.save\n format.html { redirect_to @person_equipments.last, status: 303 }\n format.json { redirect_to @person_equipments.last, status: 303 }\n else\n format.html { render :new }\n format.json { render json: @person_equipments.last.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @projectile_type = ProjectileType.new(projectile_type_params)\n\n respond_to do |format|\n if @projectile_type.save\n format.html { redirect_to @projectile_type, notice: 'Projectile type was successfully created.' }\n format.json { render :show, status: :created, location: @projectile_type }\n else\n format.html { render :new }\n format.json { render json: @projectile_type.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @grep_multi = GrepMulti.new(grep_multi_params)\n\n respond_to do |format|\n if @grep_multi.save\n format.html { redirect_to @grep_multi, notice: 'Grep multi was successfully created.' }\n format.json { render :show, status: :created, location: @grep_multi }\n else\n format.html { render :new }\n format.json { render json: @grep_multi.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @administrative_division = AdministrativeDivision.new(params[:administrative_division])\n @countries = Country.find :all\n @geo_positions = GeoPosition.find :all\n respond_to do |format|\n if @administrative_division.save\n flash[:notice] = 'AdministrativeDivision was successfully created.'\n format.html { redirect_to(@administrative_division) }\n format.xml { render :xml => @administrative_division, :status => :created, :location => @administrative_division }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @administrative_division.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @profesium = Profesium.new(profesium_params)\n\n respond_to do |format|\n if @profesium.save\n format.html { redirect_to @profesium, notice: 'Profesium was successfully created.' }\n format.json { render :show, status: :created, location: @profesium }\n else\n format.html { render :new }\n format.json { render json: @profesium.errors, status: :unprocessable_entity }\n end\n end\n end",
"def select_one population=self.population \n @sum,@wheel = wheel_core population \n @population = population\n select_one_internal\n end",
"def extractions_extraction_forms_projects_section_params\n params.require(:extractions_extraction_forms_projects_section)\n .permit(:extraction_id,\n :extraction_forms_projects_section_id,\n { status_attributes: [:name] },\n extractions_extraction_forms_projects_sections_type1s_attributes: [:type1_type_id, :units, {\n type1_attributes: %i[id name\n description], extractions_extraction_forms_projects_sections_type1_rows_attributes: [:_destroy, { population_name_attributes: %i[name description], extractions_extraction_forms_projects_sections_type1_row_columns_attributes: [:_destroy, :extractions_extraction_forms_projects_sections_type1_row_id, { timepoint_name_attributes: %i[name unit] }] }]\n }])\n end",
"def barangay_population_params\n params.require(:barangay_population).permit(:tag, :barangay_id, :name, :description, :date_info_gathered, :arb_male, :arb_female, :non_arb_male, :non_arb_female, :arb_household, :non_arb_household)\n end",
"def populate(occupancy)\n\t\tputs \"Placing #{occupancy} people in the building\"\n\t\tArray.new(occupancy).map{\n\t\t\t|person| Person.new(Faker::Name.first_name, floors.sample, floors.sample, self)\n\t\t}\n\tend",
"def create\n @gene = Gene.find(params[:gene_id])\n @feature = @gene.features.create(params[:feature])\n\n respond_to do |format|\n if @feature.save\n format.html { redirect_to @gene, notice: 'Feature was successfully created.' }\n format.json { render json: @feature, status: :created, location: @feature }\n else\n format.html { render action: \"new\" }\n format.json { render json: @feature.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n #@initiative = Initiative.new(params[:initiative])\n @initiative = Initiative.new\n @initiative.title=params[:initiative][:title]\n @initiative.description=params[:initiative][:description]\n @initiative.start=params[:initiative][:start]\n @initiative.end=params[:initiative][:end]\n @initiative.portfolio_id=params[:portfolio_id]\n @initiative.phase_id=params[:phase_id]\n @initiative.completionDegree=params[:initiative][:completionDegree]\n\n\n\n #\n # Default to the first phase in the chosen portfolio\n\n\n\n\n respond_to do |format|\n if @initiative.save\n #format.js\n format.html { render partial: 'success' }\n format.json { render json: @initiative, status: :created, location: @initiative }\n else\n #format.js\n format.html { render partial: 'fail' }\n format.json { render json: @initiative.errors, status: :unprocessable_entity }\n end\n end\n end",
"def set_extractions_extraction_forms_projects_sections_type1\n @extractions_extraction_forms_projects_sections_type1 = ExtractionsExtractionFormsProjectsSectionsType1.find(params[:id])\n end",
"def add\n # load agent\n @helper = Services::Helper.new\n\n\n agent_object = JSON.parse(File.read(\"data/agents/#{params[:agent]}.js\"))\n agent_object['identifier'] = \"#{agent_object['identifier']}_#{current_user.id}_#{@helper.random_int}\"\n @agent = Agent.create! agent_object\n @agent.events_count = 0\n @agent.last_check_at = Time.now\n \n current_user.agents.push @agent\n\n #load template\n template_object = JSON.parse(File.read(\"data/templates/#{params[:template]}.js\"))\n template_object['identifier'] = \"#{template_object['identifier']}_#{current_user.id}_#{@helper.random_int}\"\n @template = Template.create! template_object \n @template.status = 100\n @template.count = 0\n current_user.templates.push @template\n\n # create integrations\n integration_object = {}\n integration_object[:identifier] = \"#{@agent[:identifier]}_2_#{@template[:identifier]}\"\n integration_object[:title] = \"#{@agent[:title]} to #{@template[:title]}\"\n integration_object[:status] = 100\n @integration = Integration.create! integration_object \n @integration.agents.push @agent\n @integration.templates.push @template\n\n current_user.integrations.push @integration\n\n if @agent.save && @template.save && @integration.save then \n respond_to do |format|\n format.html { redirect_to @integration }\n end\n end\n end",
"def extractions_extraction_forms_projects_section_params\n params.require(:extractions_extraction_forms_projects_section)\n .permit(:extraction_id,\n :extraction_forms_projects_section_id,\n type1s_attributes: [:id, :name, :description])\n end",
"def create\n @phosphosite_feature = PhosphositeFeature.new(params[:phosphosite_feature])\n\n respond_to do |format|\n if @phosphosite_feature.save\n format.html { redirect_to @phosphosite_feature, notice: 'Phosphosite feature was successfully created.' }\n format.json { render json: @phosphosite_feature, status: :created, location: @phosphosite_feature }\n else\n format.html { render action: \"new\" }\n format.json { render json: @phosphosite_feature.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @individual = Individual.new(individual_params)\n\n respond_to do |format|\n if @individual.save\n format.html { redirect_to @individual, notice: 'Individual was successfully created.' }\n format.json { render :show, status: :created, location: @individual }\n else\n format.html { render :new }\n format.json { render json: @individual.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @inspection = Inspection.new(inspection_params)\n @clients = @inspection.try(:appointment).try(:insp_request).try(:property).try(:clients)\n create_documents\n respond_to do |format|\n if @inspection.save\n format.html { redirect_to @inspection, notice: 'Inspection was successfully created.' }\n format.json { render json: @inspection }\n else\n format.html { render :new }\n format.json { render json: @inspection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @person = Person.new(person_params)\n @person.department = Department.first\n @person.city = @person.department.cities.first\n\n respond_to do |format|\n if @person.save\n format.html { redirect_to step2_path(@person), notice: 'Person was successfully created.' }\n format.json { render :show, status: :created, location: @person }\n else\n format.html { render :new }\n format.json { render json: @person.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_students(name, cohort)\n @students << {name: name, cohort: cohort}\nend",
"def create_project_observations\n return unless params[:project_id]\n if params[:project_id].is_a?(Array)\n params[:project_id].each do |pid|\n errors = create_project_observation_records(pid)\n end\n else\n errors = create_project_observation_records(params[:project_id])\n if !errors.blank?\n if request.format.html?\n flash[:error] = t(:your_observations_couldnt_be_added_to_that_project, :errors => errors.to_sentence)\n else\n Rails.logger.error \"[ERROR #{Time.now}] Failed to add #{@observations.size} obs to #{@project}: #{errors.to_sentence}\"\n end\n end\n end\n end",
"def create\n @domicile_type_section = DomicileTypeSection.new(params[:domicile_type_section])\n\n respond_to do |format|\n if @domicile_type_section.save\n format.html { redirect_to(@domicile_type_section, :notice => 'Domicile type section was successfully created.') }\n format.xml { render :xml => @domicile_type_section, :status => :created, :location => @domicile_type_section }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @domicile_type_section.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @projection_goal_int = ProjectionGoalInt.new(projection_goal_int_params)\n\n respond_to do |format|\n if @projection_goal_int.save\n format.html { redirect_to @projection_goal_int, notice: 'Projection goal int was successfully created.' }\n format.json { render :show, status: :created, location: @projection_goal_int }\n else\n format.html { render :new }\n format.json { render json: @projection_goal_int.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @inspection = Inspection.new(params[:inspection])\n\n respond_to do |format|\n if @inspection.save\n format.html { redirect_to inspections_path, notice: t(\"activerecord.models.inspection\") + t(\"message.created\") }\n format.json { render json: @inspection, status: :created, location: @inspection }\n else\n format.html { render action: \"new\" }\n format.json { render json: @inspection.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @individual_int = IndividualInt.new(individual_int_params)\n\n respond_to do |format|\n if @individual_int.save\n format.html { redirect_to @individual_int, notice: 'Individual int was successfully created.' }\n format.json { render :show, status: :created, location: @individual_int }\n else\n format.html { render :new }\n format.json { render json: @individual_int.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add(data)\n if (@data_array.size >= @bulk_limit)\n bulk_insert(@data_array)\n @data_array.clear\n end\n\n health = [\n 'baby_hatch',\n 'clinic',\n 'dentist',\n 'doctors',\n 'hospital',\n 'nursing_home',\n 'pharmacy',\n 'social_facility',\n ]\n\n education = [\n 'college',\n 'kindergarten',\n 'library',\n 'public_bookcase',\n 'music_school',\n 'music_school',\n 'driving_school',\n 'language_school',\n 'university',\n ]\n\n finance = [\n 'atm',\n 'bank',\n 'bureau_de_change',\n ]\n\n food_amenity = [\n 'convenience',\n 'mall',\n 'supermarket',\n ]\n food_shop = [\n 'cafe',\n 'drinking_water',\n 'fast_food',\n 'food_court',\n 'ice_cream',\n 'pub',\n 'restaurant',\n ]\n\n entertainment = [\n 'arts_centre',\n 'casino',\n 'cinema',\n 'community_centre',\n 'fountain',\n 'gambling',\n 'nightclub',\n 'planetarium',\n 'social_centre',\n 'stripclub',\n 'studio',\n 'theatre',\n ]\n\n services_amenity = [\n 'social_facility',\n ]\n services_office = [\n 'accountant',\n 'advertising_agency',\n 'adoption_agency',\n 'architect',\n 'lawyer',\n 'estate_agent',\n 'copyshop',\n 'funeral_directors',\n ]\n\n\n\n if data[\"tags\"] != nil\n data[\"loc\"] = {\n type: \"Point\",\n coordinates: [data[\"lon\"].to_f, data[\"lat\"].to_f]\n }\n if health.include? data[\"tags\"][\"amenity\"]\n data[\"type\"] = 'health'\n @data_array.push(data)\n end\n if education.include? data[\"tags\"][\"amenity\"]\n data[\"type\"] = 'education'\n @data_array.push(data)\n end\n if finance.include? data[\"tags\"][\"amenity\"]\n data[\"type\"] = 'finance'\n @data_array.push(data)\n end\n if food_amenity.include?(data[\"tags\"][\"amenity\"]) || food_shop.include?(data[\"tags\"][\"shop\"])\n data[\"type\"] = 'food'\n @data_array.push(data)\n end\n\n if entertainment.include? data[\"tags\"][\"amenity\"]\n data[\"type\"] = 'entertainment'\n @data_array.push(data)\n end\n\n if services_amenity.include?(data[\"tags\"][\"amenity\"]) || services_office.include?(data[\"tags\"][\"office\"])\n data[\"type\"] = 'service'\n @data_array.push(data)\n end\n end\n #@data_array.push(data)\n end",
"def add_fish (fish)\n @fish_population << fish\n\n end",
"def update_house\n get_rep_from_api[\"results\"][0][\"members\"].each do |rep|\n Representative.create(\n pp_id: rep[\"id\"],\n first_name: rep[\"first_name\"],\n last_name: rep[\"last_name\"],\n party: rep[\"party\"],\n in_office: rep[\"in_office\"],\n state: rep[\"state\"],\n votes_with_party_pct: rep[\"votes_with_party_pct\"],\n district: rep[\"district\"]\n )\n end\nend",
"def add_person\n @project = Project.find(params[:project_id])\n @project.add_person(Person.find(params[:person_id]), false)\n render :layout => false\n end",
"def create\n @addimition = Addimition.new(params[:addimition])\n\n respond_to do |format|\n if @addimition.save\n format.html { redirect_to @addimition, notice: 'Addimition was successfully created.' }\n format.json { render json: @addimition, status: :created, location: @addimition }\n else\n format.html { render action: \"new\" }\n format.json { render json: @addimition.errors, status: :unprocessable_entity }\n end\n end\n end",
"def update_population_data(html_data)\n # Remove old population spec and create new one \n create_population_spec\n\n week_days = %w(Monday Tuesday Wednesday Thursday Friday Saturday Sunday) \n \n # parse html \n doc = Nokogiri::XML(html_data)\n\n # get first level divs under section-popular-times-container div, should be 7 \n divs = doc.xpath(\"//div[contains(@class, 'section-popular-times-container')]/div\")\n \n # process each div separately \n divs.each_with_index do |div, index|\n # create population day for current div data \n # TODO: handle existing population_day (should not happen as each \n # update should remove current population data completely)\n pop_day = PopulationDay.create(name: week_days[index], location: index)\n self.population_spec.population_days << pop_day \n \n # parse div html\n parsed_div = Nokogiri::XML(div.to_s)\n \n # get labels in div [\"79% busy at 4 pm.\", ...] \n pop_labels = parsed_div.xpath(\"//div[contains(@class,'section-popular-times-bar')]/@aria-label\").map{|i| i.value}\n \n # tmp variable for type 2 processing \n prev_hour_12 = 0\n \n pop_labels.each do |label| \n # retrieve and process data from string \n # population label has two formats: \n # 1: \"79% busy at 4 pm.\"\n # 2: \"Currently 65% busy, usually 80% busy.\"\n # determine format \n pop_lbl_split = label.split(', ')\n if pop_lbl_split.length == 2 \n # process type 2 string \n components = pop_lbl_split[1].split\n percent = components[1].chop # chop to remove % sign \n hour_24 = DateTime.strptime(prev_hour_12, '%l%P.') + 1.hour # add an hour to prev_hour_12 for correct hour \n else \n # process type 1 string \n components = pop_lbl_split[0].split\n percent = components[0].chop # chop to remove % sign \n hour_12 = components[3] + components[4]\n prev_hour_12 = hour_12 # saving this for type 2 processing \n hour_24 = DateTime.strptime(hour_12, '%l%P.') \n end\n \n # add population hour to population day of div (newly created)\n pop_hour = PopulationHour.create(\n hour: hour_24.hour, population_percent: percent) \n pop_day.population_hours << pop_hour \n end\n end\n\n self.population_spec \n end",
"def add_person_to_house\n \tbegin\n\t @house = House.find(params[:house_id])\n \t name = params[:person][:name]\n \t names = name.strip.split(' ')\n \t @person = Person.find(:first, :conditions => {:first_name => names[0], :last_name => names[1]})\n \t @house.people << @person\n \t render :update do |page|\n \t \tpage.replace_html 'house_detail', :partial => 'house', :object => @house\n \t \tpage.visual_effect :highlight, \"house_person_id_#{@person.id}\"\n \t end\n \trescue ActiveRecord::RecordNotFound\n \t #flash[:error] = \"We're sorry, there was a problem with your request. Please try again.\"\n \tend\n end",
"def add_to_regimen_type(regimen_concept)\n return nil if regimen_concept.blank?\n drug_concept = self.concept\n return nil if drug_concept.blank? or User.current_user.nil?\n concept_set = ConceptSet.new(:concept_id => drug_concept.id, :concept_set => regimen_concept.id,\n :creator => User.current_user.id, :date_created => Time.now)\n concept_set.save\n end",
"def create\n @miniature = Miniature.new(miniature_params)\n\n respond_to do |format|\n if @miniature.save\n format.html { redirect_to @miniature, notice: 'Miniature was successfully created.' }\n format.json { render :show, status: :created, location: @miniature }\n else\n format.html { render :new }\n format.json { render json: @miniature.errors, status: :unprocessable_entity }\n end\n end\n end",
"def eefps_result\n population\n .extractions_extraction_forms_projects_sections_type1\n .extractions_extraction_forms_projects_section\n .extraction_forms_projects_section\n .extraction_forms_project\n .extraction_forms_projects_sections.last\n end",
"def create\n @expenditure = Expenditure.new(params[:expenditure])\n\n respond_to do |format|\n if @expenditure.save\n format.html { redirect_to @expenditure, notice: 'Expenditure was successfully created.' }\n format.json { render json: @expenditure, status: :created, location: @expenditure }\n else\n format.html { render action: \"new\" }\n format.json { render json: @expenditure.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @interest = Interest.new(params[:interest])\n \n respond_to do |format|\n if @interest.save\n format.json { render :json => @interest,\n :status => :created, :location => @interest }\n else\n format.json { render :json => @interest.errors,\n :status => :unprocessable_entity }\n end\n end\n end",
"def create\n @pagetitle = \"New division\"\n \n @division = Division.new(params[:division])\n \n @company = Company.find(params[:division][:company_id])\n @division.company_id = @company.id\n \n @locations = @company.get_locations()\n\n respond_to do |format|\n if @division.save\n format.html { redirect_to(@division, :notice => 'Division was successfully created.') }\n format.xml { render :xml => @division, :status => :created, :location => @division }\n else\n format.html { render :action => \"new\" }\n format.xml { render :xml => @division.errors, :status => :unprocessable_entity }\n end\n end\n end",
"def create\n #@experiment = Experiment.new(params[:experiment])\n \n if(params[:experiment_id])\n @tmp_exp = Experiment.find(params[:experiment_id])\n @experiment = Experiment.new({user_id: @cur_user.id, title:\"#{@tmp_exp.title} (clone)\", content: @tmp_exp.content, filter: @tmp_exp.filter, cloned_from:@tmp_exp.id})\n success = @experiment.save\n @tmp_exp.fields.all.each do |f|\n Field.create({experiment_id:@experiment.id, field_type: f.field_type, name: f.name, unit: f.unit})\n end\n else\n @experiment = Experiment.new({user_id: @cur_user.id, title:\"#{@cur_user.firstname} #{@cur_user.lastname[0].pluralize} Experiment\"})\n success = @experiment.save\n end\n\n respond_to do |format|\n if success\n format.html { redirect_to @experiment, notice: 'Experiment was successfully created.' }\n format.json { render json: @experiment, status: :created, location: @experiment }\n else\n format.html { render action: \"new\" }\n format.json { render json: @experiment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n respond_to do |format|\n if @feature.save\n flash[:notice] = 'Feature was successfully created.'\n @changed << @feature.id\n \n format.html { redirect_to features_path }\n format.js { render 'shared/index'; flash.discard }\n format.json { render json: @feature, status: :created, location: @feature }\n else\n @edited << 'new'\n @expanded << 'new'\n\n format.html { render action: 'new', template: 'shared/new' }\n format.js { render 'feature' }\n format.json { render json: @feature.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @experiment = experiment_type_class.new(experiment_params)\n\n respond_to do |format|\n if @experiment.save\n format.html { redirect_to sti_experiment_path(@project.id, @phase.id, @experiment.type, @experiment), notice: 'Experiment was successfully created.' }\n format.json { render :show, status: :created, location: @experiment }\n else\n format.html { render :new }\n format.json { render json: @experiment.errors, status: :unprocessable_entity }\n end\n end\n end",
"def create\n @project_area_interest = ProjectAreaInterest.new(project_area_interest_params)\n\n respond_to do |format|\n if @project_area_interest.save\n format.html { redirect_to @project_area_interest }\n format.json { render :show, status: :created, location: @project_area_interest }\n else\n format.html { render :new }\n format.json { render json: @project_area_interest.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_countries\n projects = Project.find_public(:all, :conditions => [\"continent_id=?\", params[:continent_id].to_i])\n @countries = [[ 'All ...', '']]\n projects.each do |project|\n sum = 0\n projects.each do |pj|\n sum += 1 if project.country_id==pj.country_id\n end\n name = \"#{!project.country_id.nil? ? project.nation.name : project.place.country.name} (#{sum})\"\n @countries << [name, project.country_id]\n end\n @countries.uniq!\n respond_to do |format|\n format.js {\n render :update do |page|\n page.replace_html \"country_id_container\", :partial => \"select_countries\"\n end\n }\n end\n end",
"def create\n @investigationinjurylocation = Investigationinjurylocation.new(investigationinjurylocation_params)\n\n respond_to do |format|\n if @investigationinjurylocation.save\n format.html { redirect_to @investigationinjurylocation.investigation, notice: 'Investigationinjurylocation was successfully created.' }\n format.json { render :show, status: :created, location: @investigationinjurylocation }\n else\n format.html { render :new }\n format.json { render json: @investigationinjurylocation.errors, status: :unprocessable_entity }\n end\n end\n end",
"def add_industry\n\t\tif params[:ok] # OK\n industry = Industry.find_by_name params[:industry][:name]\n industry.profiles.each do |profile|\n p = Portfolio.new\n p.profile = profile\n User.find(session[:user_id]).portfolios << p\n end\n \n # Reset status and delete all Pm/investors since quotes are clear. \n reset_without_agent_reserved\n \n flash[:notice] = \"#{industry.name} industry was successfully added to your portfolio.\"\n redirect_to :action => 'list'\n\t\telse # Cancel\n\t\t\tredirect_to :action => 'list'\n\t\tend\n end",
"def update\n params[:fundation][:population_ids] ||= [] \n @fundation = Fundation.find(params[:id])\n\n respond_to do |format|\n if @fundation.update_attributes(params[:fundation])\n format.html { redirect_to(@fundation, :notice => 'Fundation was successfully updated.') }\n format.xml { head :ok }\n format.json { render :json => {:resp => \"ok\"} }\n else\n format.html { render :action => \"edit\" }\n format.xml { render :xml => @fundation.errors, :status => :unprocessable_entity }\n format.json { render :json => {:resp => \"error\"} } \n end\n end\n end",
"def town_detail_params\n params.require(:town_detail).permit(:town_id, :size, :population)\n end",
"def new\n @regulation = Regulation.new\n\n respond_to do |format|\n format.html # new.html.erb\n format.json { render json: @regulation }\n end\n end",
"def create\r\n @reduction = Reduction.new(reduction_params)\r\n @workers_create = Worker.where(workshop_id: params[:reduction][:workshop_id])\r\n\r\n respond_to do |format|\r\n if @reduction.save\r\n format.html { redirect_to reductions_path, notice: 'تم خصم المبلغ' }\r\n format.json { render :show, status: :created, location: @reduction }\r\n else\r\n format.html { render :new }\r\n format.json { render json: @reduction.errors, status: :unprocessable_entity }\r\n end\r\n end\r\n end",
"def population\n query_root_node(\"gdacs:population/text()\", @@NAMESPACES)\n end",
"def add_ingredients\n rid = params['id']\n name = params['name']\n quant = params['quantity']\n meas = params['measurement']\n\n ingredients = {\n 'name' => name,\n 'quantity' => quant,\n 'measurement' => meas,\n }\n\n if Aws.save_ingredient_to_db(rid, ingredients)\n msg = {:notice => \"Ingredient created!\"}\n render :json => msg\n else\n msg = {:notice => \"Error while creating ingredient!\"}\n render :json => msg\n end\n end",
"def create\n @diabetic = Diabetic.new(diabetic_params)\n\n respond_to do |format|\n if @diabetic.save\n format.html { redirect_to @diabetic, notice: 'Diabetic was successfully created.' }\n format.json { render :show, status: :created, location: @diabetic }\n else\n format.html { render :new }\n format.json { render json: @diabetic.errors, status: :unprocessable_entity }\n end\n end\n end"
] |
[
"0.7874224",
"0.6710033",
"0.6270805",
"0.6023102",
"0.55719763",
"0.55287224",
"0.55287224",
"0.5522431",
"0.54312444",
"0.53367424",
"0.5334908",
"0.52677965",
"0.51416105",
"0.5138206",
"0.50998086",
"0.5098964",
"0.5084003",
"0.5073172",
"0.50245917",
"0.50188595",
"0.50118876",
"0.4976757",
"0.49738625",
"0.49706516",
"0.49678442",
"0.49593148",
"0.4948547",
"0.49391186",
"0.4935201",
"0.4928212",
"0.49243188",
"0.48867342",
"0.486923",
"0.4859034",
"0.4855046",
"0.48508897",
"0.48325217",
"0.48290458",
"0.48065838",
"0.47963983",
"0.47932312",
"0.47850567",
"0.4783833",
"0.47819662",
"0.47673038",
"0.47622898",
"0.47614583",
"0.47605962",
"0.47565806",
"0.47525668",
"0.47441527",
"0.4739568",
"0.4726496",
"0.47205907",
"0.4718082",
"0.47100267",
"0.4706173",
"0.4702662",
"0.4701591",
"0.4701295",
"0.46945533",
"0.4686449",
"0.46825078",
"0.46820357",
"0.46723366",
"0.46703875",
"0.46654055",
"0.46610397",
"0.4651745",
"0.46425167",
"0.46363807",
"0.46294665",
"0.46283838",
"0.46257383",
"0.46207213",
"0.46127194",
"0.4607127",
"0.4606162",
"0.46046415",
"0.460263",
"0.4597728",
"0.4595383",
"0.4594909",
"0.45947495",
"0.4587302",
"0.4584369",
"0.45825002",
"0.45817608",
"0.45788643",
"0.45785555",
"0.45772782",
"0.45764923",
"0.45733652",
"0.45711157",
"0.4567017",
"0.45662194",
"0.45653182",
"0.45636553",
"0.45556453",
"0.4551598"
] |
0.8248006
|
0
|
Use callbacks to share common setup or constraints between actions.
|
def set_extractions_extraction_forms_projects_sections_type1
@extractions_extraction_forms_projects_sections_type1 = ExtractionsExtractionFormsProjectsSectionsType1.find(params[:id])
authorize(@extractions_extraction_forms_projects_sections_type1)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def set_required_actions\n # TODO: check what fields change to asign required fields\n end",
"def action_hook; end",
"def run_actions; end",
"def define_action_hook; end",
"def actions; end",
"def define_action_helpers\n if super && action == :save\n @instance_helper_module.class_eval do\n define_method(:valid?) do |*args|\n self.class.state_machines.fire_event_attributes(self, :save, false) { super(*args) }\n end\n end\n end\n end",
"def add_actions; end",
"def callbacks; end",
"def callbacks; end",
"def setup *actions, &proc\n (@setup_procs ||= []) << [proc, actions.size > 0 ? actions : [:*]]\n end",
"def define_action_helpers; end",
"def post_setup\n end",
"def action_methods; end",
"def action_methods; end",
"def action_methods; end",
"def before_setup; end",
"def action_run\n end",
"def execute(setup)\n @action.call(setup)\n end",
"def define_action_helpers?; end",
"def set_actions\n actions :all\n end",
"def action_done(action)\n dispatch = { :migrate => :done_migrating, :map => :done_mapping, :reduce =>\n :done_reducing, :finalize => :done_finalizing } \n self.send dispatch[action[:action]], action\n end",
"def dependencies action, &block\n @actions.each do |other|\n if action[:requires].include? other[:provide]\n block.call other\n end\n end\n end",
"def setup!\n return unless @setup_procs\n http_actions = actions\n @setup_procs.each do |setup_proc|\n proc, actions = setup_proc\n @setup__actions = actions.map do |action|\n\n action.is_a?(Regexp) ?\n http_actions.select { |a| a.to_s =~ action } :\n action.is_a?(String) && action =~ /\\A\\./ ?\n http_actions.map { |a| a.to_s << action if format?(a).include?(action) }.compact :\n action\n\n end.flatten\n self.class_exec &proc\n @setup__actions = nil\n end\n @setup_procs = nil\n end",
"def before_actions(*logic)\n self.before_actions = logic\n end",
"def setup_handler\n end",
"def set_action(opts)\n opts = check_params(opts,[:actions])\n super(opts)\n end",
"def setup(action)\n @targets.clear\n unless action.item.target_filters.empty?\n @targets = SES::TargetManager.make_targets(action)\n else\n item = action.item\n if item.for_opponent?\n @targets = $game_troop.alive_members\n elsif item.for_dead_friend?\n @targets = $game_party.battle_members.select { |actor| actor.dead? }\n else\n $game_party.battle_members.select { |actor| actor.alive? }\n end\n end\n @item_max = @targets.size\n create_contents\n refresh\n show\n activate\n end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def action; end",
"def workflow\n end",
"def revisable_shared_setup(args, block)\n class << self\n attr_accessor :revisable_options\n end\n options = args.extract_options!\n self.revisable_options = Options.new(options, &block)\n \n self.send(:include, Common)\n self.send(:extend, Validations) unless self.revisable_options.no_validation_scoping?\n self.send(:include, WithoutScope::QuotedColumnConditions)\n end",
"def setup\n @action = SampleActionAndroid.new(os_name: 'android',\n app_name: APP_PATH)\n end",
"def before(action)\n invoke_callbacks *self.class.send(action).before\n end",
"def process_action(...)\n send_action(...)\n end",
"def before_dispatch(env); end",
"def after_actions(*logic)\n self.after_actions = logic\n end",
"def setup\n # override and do something appropriate\n end",
"def setup(client)\n return unless @setup\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n actions.each do |action|\n action.execute(client)\n end\n self\n end",
"def setup(_context)\n end",
"def setup(resources) ; end",
"def validate_actions\n errors.add(:base, :should_give_at_least_one_action) if !manage? && !forecasting? && !read? && !api?\n end",
"def setup\n @resource_config = {\n :callbacks => {\n :before_create => nil,\n :after_create => nil,\n :before_update => nil,\n :after_update => nil,\n :before_destroy => nil,\n :after_destroy => nil,\n },\n :child_assoc => nil,\n :model => nil,\n :parent => nil,\n :path => nil,\n :permission => {},\n :properties => {},\n :relation => {\n :create => nil,\n :delete => nil,\n },\n :roles => nil,\n }\n end",
"def determine_valid_action\n\n end",
"def process_shared\n handle_taxes\n handle_shippings\n create_adjustments_from_params\n handle_status\n handle_inventory_refunds\n handle_payment_transactions\n order.updater.update\n end",
"def startcompany(action)\n @done = true\n action.setup\n end",
"def init_actions\n am = action_manager()\n am.add_action(Action.new(\"&Disable selection\") { @selection_mode = :none; unbind_key(32); bind_key(32, :scroll_forward); } )\n am.add_action(Action.new(\"&Edit Toggle\") { @edit_toggle = !@edit_toggle; $status_message.value = \"Edit toggle is #{@edit_toggle}\" })\n end",
"def event_callbacks(event, metadata={})\n case event\n when :reset, :review\n if confirmed\n update_attributes(confirmed: false)\n end\n when :confirm\n confirm\n # trigger :order for all applicable items\n # NOTE: :order event is common to both physical and digital items\n items.each do |i|\n if i.event_permitted(:order)\n user_id = last_transition.user_id\n i.trigger!(:order, { order_id: id, user_id: user_id })\n end\n end\n when :complete_work\n request = metadata[:request]\n work_complete_notification(request)\n when :close\n close\n end\n if event != :close && !open\n reopen\n end\n end",
"def setup_action\n return unless PONY::ERRNO::check_sequence(current_act)\n new_sequence = @action_sequence[@sequence_index+1...@action_sequence.size]\n @sequence_index = 0\n new_sequence = DND::SkillSequence::ACTS[@acts[1]] + new_sequence\n execute_sequence\n end",
"def define_tasks\n define_weave_task\n connect_common_tasks\n end",
"def setup(&block)\n define_method(:setup, &block)\n end",
"def setup\n transition_to(:setup)\n end",
"def setup\n transition_to(:setup)\n end",
"def action\n end",
"def setup( *args )\n\t\t\tself.class.setupBlocks.each {|sblock|\n\t\t\t\tdebugMsg \"Calling setup block method #{sblock}\"\n\t\t\t\tself.send( sblock )\n\t\t\t}\n\t\t\tsuper( *args )\n\t\tend",
"def config(action, *args); end",
"def setup\n @setup_proc.call(self) if @setup_proc\n end",
"def before_action \n end",
"def setup_callbacks\n defined_callbacks.each do |meth|\n unless respond_to?(\"call_#{meth}_callbacks\".to_sym)\n self.class.module_eval <<-EOE\n def call_#{meth}_callbacks(*args)\n plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store\n self.send :#{meth}, *args if respond_to?(:#{meth})\n end\n EOE\n end\n end\n end",
"def action\n end",
"def matt_custom_action_begin(label); end",
"def setup\n # override this if needed\n end",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def setup\n\t\t\t\t\t\t# Do nothing\n\t\t\t\tend",
"def action(options,&callback)\n new_action = Action===options ? options : Action.new(options,&callback)\n # replace any with (shared name/alias or both default) + same arity\n @actions.delete_if do |existing_action|\n ((existing_action.names & new_action.names).size > 0 ||\n existing_action.default? && new_action.default?) &&\n existing_action.required.size == new_action.required.size &&\n existing_action.optional.size <= new_action.optional.size\n end\n @actions = (@actions + [new_action]).sort\n new_action\n end",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action\n end",
"def after(action)\n invoke_callbacks *options_for(action).after\n end",
"def pre_task\n end",
"def setup(server)\n server.on('beforeMethod', method(:before_method), 10)\n end",
"def add_actions\n attribute = machine.attribute\n name = self.name\n \n owner_class.class_eval do\n define_method(name) {self.class.state_machines[attribute].events[name].fire(self)}\n define_method(\"#{name}!\") {self.class.state_machines[attribute].events[name].fire!(self)}\n define_method(\"can_#{name}?\") {self.class.state_machines[attribute].events[name].can_fire?(self)}\n end\n end",
"def init_actions\n @select_action = SelectAction.new\n @endpoint_mouse_action = EndpointMouseAction.new\n @move_action = MoveAction.new\n end",
"def setup_signals; end",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def after_created\r\n return unless compile_time\r\n Array(action).each do |action|\r\n run_action(action)\r\n end\r\nend",
"def set_target_and_action target, action\n self.target = target\n self.action = 'sugarcube_handle_action:'\n @sugarcube_action = action.respond_to?('weak!') ? action.weak! : action\n end",
"def initialize(*args)\n super\n @action = :set\nend",
"def after_set_callback; end",
"def setup\n #implement in subclass;\n end",
"def lookup_action; end",
"def setup &block\n if block_given?\n @setup = block\n else\n @setup.call\n end\n end",
"def setup_action\n return TSBS.error(@acts[0], 1, @used_sequence) if @acts.size < 2\n actions = TSBS::AnimLoop[@acts[1]]\n if actions.nil?\n show_action_error(@acts[1])\n end\n @sequence_stack.push(@acts[1])\n @used_sequence = @acts[1]\n actions.each do |acts|\n @acts = acts\n execute_sequence\n break if @break_action\n end\n @sequence_stack.pop\n @used_sequence = @sequence_stack[-1]\n end",
"def release_actions; end",
"def around_hooks; end",
"def save_action; end",
"def setup(easy)\n super\n easy.customrequest = @verb\n end",
"def action_target()\n \n end",
"def setup\n callback(:setup) do\n notify(:setup)\n migration_check.last_deployed_commit\n end\n end",
"def setup\n return unless @setup\n\n actions = @setup['setup'].select { |action| action['do'] }.map { |action| Action.new(action['do']) }\n run_actions_and_retry(actions)\n self\n end",
"def before_setup\n # do nothing by default\n end",
"def my_actions(options)\n @setup = false\n get_template_part(\"custom_used\",\"action_users\",true)\n end",
"def default_action; end",
"def setup(&blk)\n @setup_block = blk\n end",
"def callback_phase\n super\n end",
"def advice\n end",
"def _handle_action_missing(*args); end",
"def duas1(action)\n action.call\n action.call\nend",
"def shared_action(name, &block)\n @controller.shared_actions[name] = block\n end",
"def before_action action, &block\n @audience[:before][action] ||= Set.new\n @audience[:before][action] << block\n end",
"def setup_initial_state\n\n state_a = State.new(\"a\", 0)\n state_b = State.new(\"b\", 0)\n state_c = State.new(\"c\", 10)\n\n move_to_b = Action.new(\"move_to_b\", 1, state_b)\n\n move_to_c = Action.new(\"move_to_c\", 1, state_c)\n\n state_a.actions = [move_to_b, move_to_c]\n\n return state_a\n \nend"
] |
[
"0.6163163",
"0.6045976",
"0.5946146",
"0.591683",
"0.5890051",
"0.58349305",
"0.5776858",
"0.5703237",
"0.5703237",
"0.5652805",
"0.5621621",
"0.54210985",
"0.5411113",
"0.5411113",
"0.5411113",
"0.5391541",
"0.53794575",
"0.5357573",
"0.53402257",
"0.53394014",
"0.53321576",
"0.53124547",
"0.529654",
"0.5296262",
"0.52952296",
"0.52600986",
"0.52442724",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.52385926",
"0.5232394",
"0.523231",
"0.5227454",
"0.52226824",
"0.52201617",
"0.5212327",
"0.52079266",
"0.52050185",
"0.51754695",
"0.51726824",
"0.51710224",
"0.5166172",
"0.5159343",
"0.51578903",
"0.51522785",
"0.5152022",
"0.51518047",
"0.51456624",
"0.51398855",
"0.5133759",
"0.5112076",
"0.5111866",
"0.5111866",
"0.5110294",
"0.5106169",
"0.509231",
"0.50873137",
"0.5081088",
"0.508059",
"0.50677156",
"0.50562143",
"0.5050554",
"0.50474834",
"0.50474834",
"0.5036181",
"0.5026331",
"0.5022976",
"0.5015441",
"0.50121695",
"0.5000944",
"0.5000019",
"0.4996878",
"0.4989888",
"0.4989888",
"0.49864885",
"0.49797225",
"0.49785787",
"0.4976161",
"0.49683493",
"0.4965126",
"0.4958034",
"0.49559742",
"0.4954353",
"0.49535993",
"0.4952725",
"0.49467874",
"0.49423352",
"0.49325448",
"0.49282882",
"0.49269363",
"0.49269104",
"0.49252945",
"0.4923091",
"0.49194667",
"0.49174926",
"0.49173003",
"0.49171105",
"0.4915879",
"0.49155936"
] |
0.0
|
-1
|
Never trust parameters from the scary internet, only allow the white list through.
|
def extractions_extraction_forms_projects_sections_type1_params
params.require(:extractions_extraction_forms_projects_sections_type1)
.permit(:type1_type_id, :extractions_extraction_forms_projects_section_id, :type1_id, :units,
should: :propagate,
type1_attributes: %i[id name description],
extractions_extraction_forms_projects_sections_type1_rows_attributes: [
:id, :_destroy,
{ population_name_attributes: %i[id name description],
extractions_extraction_forms_projects_sections_type1_row_columns_attributes: [
:id, :_destroy,
{ timepoint_name_attributes: %i[id name unit] }
] }
])
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def strong_params\n params.require(:user).permit(param_whitelist)\n end",
"def strong_params\n params.require(:listing_member).permit(param_whitelist)\n end",
"def allow_params_authentication!; end",
"def allowed_params\n ALLOWED_PARAMS\n end",
"def default_param_whitelist\n [\"mode\"]\n end",
"def param_whitelist\n [:role, :title]\n end",
"def expected_permitted_parameter_names; end",
"def safe_params\n params.except(:host, :port, :protocol).permit!\n end",
"def strong_params\n params.require(:team_member).permit(param_whitelist)\n end",
"def permitir_parametros\n \t\tparams.permit!\n \tend",
"def strong_params\n params.require(:community).permit(param_whitelist)\n end",
"def permitted_strong_parameters\n :all #or an array of parameters, example: [:name, :email]\n end",
"def strong_params\n params.require(:education).permit(param_whitelist)\n end",
"def restricted_params\n #params.require(self.controller_name.classify.underscore.to_sym).permit([])\n raise(\"No strong params set, override restricted_params method in your controller. E.g. params.require(:model).permit(:attribute1, :attribute2)\")\n end",
"def allowed_params\n params.require(:user).permit(:username, :email, :password, :password_confirmation)\n end",
"def param_whitelist\n [:rating, :review]\n end",
"def param_whitelist\n whitelist = [\n :username, :name,\n :parent_id,\n :headline, :description, :video,\n :policy, :signup_mode, :category,\n :website, :facebook, :twitter, :linkedin,\n :founded_at,\n privacy: [\n :events,\n :resources\n ],\n permission: [\n :profile,\n :members,\n :children,\n :statistics,\n :posts,\n :listings,\n :resources,\n :events\n ],\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:parent_id)\n unless current_user.role_in(@community) === 'owner'\n whitelist.delete(:privacy)\n whitelist.delete(:permission)\n end\n end\n \n whitelist\n end",
"def param_whitelist\n if @user.present? && current_user != @user\n return [:followed]\n end\n \n whitelist = [\n :username, :email, :password,\n :first_name, :last_name,\n :birthday, :gender,\n :headline, :biography, :ask_about, :focus,\n :website, :facebook, :linkedin, :twitter, :github,\n roles: [],\n skills: [],\n interests: [],\n privacy: { contact: [] },\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n \n if action_name === 'update'\n whitelist.delete(:email)\n whitelist.delete(:password)\n end\n \n whitelist\n end",
"def user_params \n \tparams.require(:user).permit(:name, :email, :password, :password_confirmation)# preventing CSTR\n end",
"def user_params\n params.permit(:name, :phoneNumber, :address, :postalCode, :local, :link, :counter, :latitude, :longitude) \n end",
"def valid_params_request?; end",
"def strong_params\n params.require(:experience).permit(param_whitelist)\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def whitelist_url_params\n params.require(:whitelist_url).permit(:domain)\n end",
"def allowed_params\n params.require(:allowed).permit(:email)\n end",
"def permitted_params\n []\n end",
"def trim_whitelisted(params, whitelist)\n # remove any parameters that are not whitelisted\n params.each do |key, value|\n # if white listed\n if whitelist.include? key\n # strip the parameters of any extra spaces, save as string\n params[key] = value.to_s.strip\n else\n # delete any unauthorized parameters\n params.delete key\n end\n end\n params\n end",
"def safe_params\n params.permit(:id, :name, :origin, :emails => []); #emails is an array\n end",
"def query_param\n\t\tparams.permit(:first_name, :last_name, :phone)\n\tend",
"def strong_params\n params.require(:success_metric).permit(param_whitelist)\n end",
"def devise_filter\r\n logger.debug(\"In devise_filter =>PARAMS: #{params.inspect}\")\r\n\r\n # White list for sign_up\r\n devise_parameter_sanitizer.for(:sign_up) { |u| u.permit(user_whitelist) }\r\n\r\n # White list for account update\r\n devise_parameter_sanitizer.for(:account_update) { |u| u.permit(user_whitelist, :current_password) }\r\n\r\n # White list for Invitation creation\r\n devise_parameter_sanitizer.for(:invite) { |u| u.permit(:account_type, :email, :invitation_token)}\r\n\r\n # White list for accept invitation\r\n devise_parameter_sanitizer.for(:accept_invitation) { |u| u.permit(user_whitelist, :invitation_token)}\r\n\r\n end",
"def whitelisted_user_params\n params.require(:user).\n permit( :first_name, :last_name, :email,:password,:password_confirmation,:birthday,:gender)\n end",
"def user_params\n ActionController::Parameters.permit_all_parameters = true\n params.require(:user) #.permit(:name, :surname, :phone, :password, :email, :time_zone)\n end",
"def strong_params\n params.require(:metric_change).permit(param_whitelist)\n end",
"def safe_params\n params.require(:user).permit(:name)\n end",
"def get_params\n\t\treturn ActionController::Parameters.new(self.attributes).permit(\"account_id\", \"title\", \"category\", \"introduction\", \"tags\", \"segment_type\", \"visible\", \"status\", \"main_image\")\n\tend",
"def grant_params\n @whitelisted = params.require(:grant).permit(:name, :description, :agency_id, :acronym)\n end",
"def check_params; true; end",
"def param_whitelist\n whitelist = [\n :description,\n :progress,\n :kpi_id\n ]\n \n unless action_name === 'create'\n whitelist.delete(:kpi_id)\n end\n \n whitelist\n end",
"def quote_params\n params.permit!\n end",
"def valid_params?; end",
"def paramunold_params\n params.require(:paramunold).permit!\n end",
"def user_params\n\t\tparams.permit(:nickname, :avatar, :description, :password, :gender, :birthday, :email, :phone, :qq_id, :wechat_id)\n\tend",
"def filtered_parameters; end",
"def user_params\n params.permit(\n \t:id,\n \t:email, \n \t:first_name, \n \t:last_name, \n \t:password, \n \t:confirm_token, \n \t:phone_number,\n \t:facebook_link,\n \t:car_model,\n \t:license_plate)\n end",
"def filtering_params\n params.permit(:email, :name)\n end",
"def check_params\n true\n end",
"def wx_public_params\n params.require(:wx_public).permit(:nickname, :manager, :alias)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def allowed_params\n params.require(:user).permit(:email, :password, :role, :first_name, :last_name, :password_confirmation)\n end",
"def listing_params\n\t\tparams.permit(:address, :transit_info, :rules, :other_info, :lat, :lng)\n\tend",
"def social_account_params\n\t\t\tparams.require(:social_account).permit!\n\t\tend",
"def safe_params\n resurce_name = self.class.resource_name\n params_method_name = \"#{resurce_name}_params\".to_sym\n if params[resurce_name]\n if respond_to?(params_method_name) || private_methods.include?(params_method_name)\n send(params_method_name)\n else\n raise ActiveModel::ForbiddenAttributesError, \"Please, define the '#{params_method_name}' method in #{self.class.name}\"\n end\n end\n end",
"def url_params\n params.require(:url).permit(:short_url, :original_url, :clicks, :ip_addresses)\n end",
"def user_params\n params.require(:user).permit(:uri, :username, :password, :realname, :email, :publicvisible)\n end",
"def model_params\n\t\tparams.require(:manager).permit(\n\t :user_name,\n :password,\n :email,\n \t\t\t)\n\tend",
"def article_params_whitelist\n params.require(:article).permit(:title, :description, category_ids: [])\n end",
"def college_whitelist_params\n params.require(:college_whitelist).permit(:status)\n end",
"def active_code_params\n params[:active_code].permit\n end",
"def filtering_params\n params.permit(:email)\n end",
"def valid_params(params)\n params.permit(:user_id, :photo_id, :originX, :originY, :width, :height)\n end",
"def ip_address_params\n\t\t\tparams.require(:ip_address).permit!\n end",
"def pull_request_params\n whitelist = [\n :url,\n :id,\n :html_url,\n :diff_url,\n :patch_url,\n :issue_url,\n :number,\n :state,\n :locked,\n :title\n ]\n params.require(:pull_request).permit(whitelist)\n end",
"def reserved_params\n params.require(:reserved).permit(:name, :email, :pax, :address, :KTP, :title)\n end",
"def post_params\n if current_user.admin? \n params.permit(:title, :body, :city, :country, :gps_location, :privacy, :visible, :latitude, :longitude, images: [], files: [])\n else \n params.permit(:title, :body, :city, :country, :gps_location, :privacy,:latitude, :longitude, images: [], files: [])\n end \n end",
"def list_params\n params.permit(:name)\n end",
"def filter_parameters; end",
"def filter_parameters; end",
"def vineyard_params\n params.permit(:vineyard_name, :email, :website_url, :phone, :address, :city, :region, :postcode, :country, :specialty, :description, :pet_friendly, :holiday, :tours, :events, :family_friendly, :cover_image, :image_one, :image_two, :image_three, :image_four, :user_id, :base64)\n end",
"def available_activity_params\n # params.require(:available_activity).permit(:type,:geometry,:properties)\n whitelisted = ActionController::Parameters.new({\n type: params.require(:available_activity)[:type],\n geometry: params.require(:available_activity)[:geometry].try(:permit!).to_h,\n properties: params.require(:available_activity)[:properties].try(:permit!).to_h\n }).try(:permit!)\n end",
"def user_params\n params.permit(:name, :username, :email, :password, :img_url, :bg_url, :coinbank)\n end",
"def user_params_pub\n\t \tparams[:user].permit(:hruid)\n\t end",
"def user_params\n params.permit(:id, :email, :password, :nickname, :status, :avatar, :flat_picture, :flatsharing_id, :member,\n :user, :color, :solde)\n end",
"def validate_search_inputs\n @whitelisted = params.fetch(:user, nil)\n if @whitelisted.blank?\n render_error(400, \"#{I18n.t('general_error.params_missing_key')}\": [I18n.t('general_error.params_missing_value', model: \"review\")])\n return\n else\n @whitelisted = @whitelisted.permit(:name, :uen, :description)\n end\n end",
"def param_whitelist\n [\n :title,\n :description,\n :organization,\n :team_id,\n :started_at,\n :finished_at,\n location: [\n :description,\n :street,\n :city,\n :state,\n :zip,\n :country,\n :latitude,\n :longitude\n ]\n ]\n end",
"def url_whitelist; end",
"def admin_social_network_params\n params.require(:social_network).permit!\n end",
"def filter_params\n params.require(:filters).permit(:letters)\n end",
"def origin_params\n params.permit(:country, :state, :city, :postal_code, :address, :description)\n end",
"def valid_params(params)\n params.permit(:login, :first_name, :last_name, \n :password, :password_confirmation)\n end",
"def sensitive_params=(params)\n @sensitive_params = params\n end",
"def permit_request_params\n params.permit(:address)\n end",
"def user_params\n # Ensure a user can't give themselves admin priveleges\n params.delete(:admin) if current_user.admin?\n params.require(:user).permit(:name, :email, :admin, :image)\n end",
"def secure_params\n params.require(:location).permit(:name)\n end",
"def strong_params\n params.require( :setting ).\n permit( :global_scan_limit, :per_user_scan_limit,\n :target_whitelist_patterns, :target_blacklist_patterns )\n end",
"def question_params\n params.require(:survey_question).permit(question_whitelist)\n end",
"def case_insensitive_params\n params.require(:case_insensitive).permit(:name)\n end",
"def empire_master_no_match_params\n params.require(:empire_master_no_match).permit(:uid, :last_name, :list, :search_date, :double, :source)\n end",
"def maintenance_request_params\n params[:maintenance_request].permit! #allow all parameters for now\n end",
"def unwanted_params\n params.require(:unwanted).permit(:title, :description, :image)\n end",
"def url_params\n params[:url].permit(:full)\n end",
"def backend_user_params\n params.permit!\n end",
"def filter_params\n\t\treturn params[:candidate].permit(:name_for_filter)\n\tend",
"def speed_measurement_params\n\n #fuckit, to lazy to deal with permit crap right now\n ActionController::Parameters.permit_all_parameters = true\n\n params[:speed_measurement]\n end",
"def user_params\n params.permit(:name, :age, :username, :display_photo, :password)\n end",
"def get_params\r\n #params.require(:article).permit(:title, :permalink, :content, :source_site, :introtext, :type_id, :order_by, :searchable, :created_by, :edited_by, :published_by, :published_on, :user_id)\r\n params.require(:article).permit!\r\n\r\n end",
"def pub_params\n params.require(:pub).permit(:name, :description, :phone, :email, :hidden, :city_id, :address)\n end",
"def pass_params\n params[:pass].permit(:name, :price, :description, :colour, :events)\n end",
"def droptraining_params\n params.permit(:training_id,:user_id, :utf8, :authenticity_token, :commit)\n end",
"def person_params\n # params whitelist does *not* include admin, sub, remember_token\n # TBD: share this whitelist with the list used by configuration_permitted_parameters\n # TBD: should current_password be on this list? -- for now, leaving off, since it seems to work without\n # NOTE: do not include 'admin' in this list!\n params.require(:person).permit(\n :name, \n :email, \n :description,\n :password, \n :password_confirmation\n )\n end",
"def parameter_params\n params.require(:parameter).permit(:name, :description, :param_code, :param_value, :active_from, :active_to)\n end"
] |
[
"0.69792545",
"0.6781151",
"0.67419964",
"0.674013",
"0.6734356",
"0.6591046",
"0.6502396",
"0.6496313",
"0.6480641",
"0.6477825",
"0.64565",
"0.6438387",
"0.63791263",
"0.63740575",
"0.6364131",
"0.63192815",
"0.62991166",
"0.62978333",
"0.6292148",
"0.6290449",
"0.6290076",
"0.62894756",
"0.6283177",
"0.6242471",
"0.62382483",
"0.6217549",
"0.6214457",
"0.6209053",
"0.6193042",
"0.6177802",
"0.6174604",
"0.61714715",
"0.6161512",
"0.6151757",
"0.6150663",
"0.61461",
"0.61213595",
"0.611406",
"0.6106206",
"0.6105114",
"0.6089039",
"0.6081015",
"0.6071004",
"0.60620916",
"0.6019971",
"0.601788",
"0.6011056",
"0.6010898",
"0.6005122",
"0.6005122",
"0.6001556",
"0.6001049",
"0.59943926",
"0.5992201",
"0.59909594",
"0.5990628",
"0.5980841",
"0.59669393",
"0.59589154",
"0.5958826",
"0.5957911",
"0.5957385",
"0.5953072",
"0.59526145",
"0.5943361",
"0.59386164",
"0.59375334",
"0.59375334",
"0.5933856",
"0.59292704",
"0.59254247",
"0.5924164",
"0.59167904",
"0.59088355",
"0.5907542",
"0.59064597",
"0.5906243",
"0.5898226",
"0.589687",
"0.5896091",
"0.5894501",
"0.5894289",
"0.5891739",
"0.58860534",
"0.5882406",
"0.587974",
"0.58738774",
"0.5869024",
"0.58679986",
"0.5867561",
"0.5865932",
"0.5864461",
"0.58639693",
"0.58617616",
"0.5861436",
"0.5860451",
"0.58602303",
"0.5854586",
"0.58537364",
"0.5850427",
"0.5850199"
] |
0.0
|
-1
|
def index user = User.find_by(id: params['user_id']) expenses = user.expenses.all render json: debts end
|
def create
user = User.find_by(id: expense_params['user_id'])
debt = Debt.find_by(id: expense_params['debt_id'])
expense = user.expenses.build(expense_params)
if expense.save
if debt
debt.expenses << expense
end
render json: user
else
render json: expense.errors, status: :unprocessable_entity
end
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def index\n if current_user\n \t@debts = Debt.paginate(:page => params[:page], :per_page => 10)\n \trespond_to do |format|\n \tformat.html # index.html.erb\n \tformat.json { render json: @debts }\n \tend\n end\n end",
"def index\n @expenses = find_expenses.all\n render json: @expenses\n end",
"def index\n @expenses = current_user.user_account.expenses\n #DZF get totals\n\t\tunless @expenses.blank?\n\t\t\t@expense_total_price = current_user.user_account.get_expenses_total_price\n\t\t\t@expense_total_payed_price = current_user.user_account.get_expenses_total_total_payed_price\n\t\t\t@expense_total_payed_percentage = @expense_total_payed_price / @expense_total_price * 100\n\t\t\t@expense_total_remaining_price = current_user.user_account.get_expenses_total_remaining_price\n\t\t\t#DZF get payers percentage\n\t\t\t@payer_types_totals = {}\n\t\t\tPayerType.all.each do |pt|\n\t\t\t\t@payer_types_totals.merge!({pt.name => (current_user.user_account.get_payer_total_price_by_id(pt.id) * 100 / @expense_total_price) } )\n\t\t\tend\n\t\tend\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @expenses }\n end\n end",
"def index\n @expenses = Expense.all\n # @assets = Asset.all\n @assets = current_user.assets\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @expenses }\n end\n end",
"def index\n @expenses = Expense.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @expenses }\n end\n end",
"def index\n @expenses = current_user.expenses.date_between(params[:from],params[:to]).order('created_at DESC')\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @expenses }\n end\n end",
"def index\n @petty_cash_expenses = PettyCashExpense.all\n render json: @petty_cash_expenses\n end",
"def index\n @fixed_expenses = FixedExpense.for_user(current_user).all\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @fixed_expenses }\n end\n end",
"def index\n\n @debtors = Debtor.all\n\n render json: @debtors\n end",
"def index\n @budgets = Budget.find_owned_by current_user\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @budgets }\n end\n end",
"def index\n @bid_expenses = BidExpense.all\n end",
"def index\n @deposits = Deposit.all\n @balance = 0\n @deposits.each do |d|\n if d.user_id == current_user.id\n @balance = @balance + d.amount\n end\n end\n end",
"def index\n @expenses = Expense.all\n respond_with @expenses\n end",
"def show\n @transactions = Transaction.where(user_id: params[:id])\n render json: @transactions\n end",
"def index\n @purchases = Purchase.where(user_id: get_current_user.id.to_i)\n\n render json: @purchases\n end",
"def index\n @debts = Debt.includes(:kreditur, :debitur).where(\"kreditur_id = ? or debitur_id = ?\", current_user.id, current_user.id)\n @utangs = @debts.where(kreditur_id: current_user.id)\n @piutangs = @debts.where(debitur_id: current_user.id)\n end",
"def index\n @debts = Debt.all\n end",
"def index\n @debts = Debt.all\n end",
"def index\r\n @deposits = []\r\n if current_user.admin?\r\n @deposits = Deposit.all\r\n else\r\n @deposits = Deposit.where(user_id: current_accounts.collect{|x| x.acct_number})\r\n end\r\n end",
"def index\n\n # authenticate request\n if auth_user\n\n # check user has data to show\n if Expense.user(@user).count ==0\n render json: { message: \"You have no data - please submit date via a POST request\" }, status: 401\n else\n\n # retrieve paramaters\n # set start and end date to data min/max if not provided \n start_date = params[:start_date].respond_to?(:to_date) ? params[:start_date].to_date : Expense.user(@user).min_by(&:date).date\n end_date = params[:end_date].respond_to?(:to_date) ? params[:end_date].to_date : Expense.user(@user).max_by(&:date).date\n category = params[:category]\n\n # request category if provided (uses scopes defined in Expense model)\n if category == nil\n @expenses = Expense.user(@user).after_date(start_date).before_date(end_date)\n else\n @expenses = Expense.user(@user).after_date(start_date).before_date(end_date).category(category)\n end\n end\n\n else\n # request not authenticated\n return render json: { message: \"Invalid Token\", status: 400}, status: 400\n end\n end",
"def index\n @expenses = Expense.all\n end",
"def my_transactions\n @transactions = Transaction.find_all_by_user_id(current_user.id)\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @transactions }\n end\n end",
"def index\n\t\tunless User.healthy? params[:user_id]\n \t \trender json: { error: \"Denied access. User is contaminated!\" }, status: 403 and return\n \tend\n\n\t\tinventory = Inventory.where(user_id: params[:user_id])\n\t\trender json: inventory, status: 200 \n\tend",
"def index\n @purchases = Purchase.find_all_by_user_id(current_user.id)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @purchases }\n end\n end",
"def index\n @expense_transactions = ExpenseTransaction.all\n end",
"def index\n @ledger_accounts = current_user.ledger_accounts.all\n respond_with @ledger_accounts\n end",
"def index\n @ledger_accounts = current_user.ledger_accounts.all\n respond_with @ledger_accounts\n end",
"def index\n\t\ttransaction = Transaction.where(user_id: params[:user_id])\n\n\t\tif transaction\n\t\t\trender json: transaction,status: 200\n\t\telse\n\t\t\trender json: transaction.errors.messages,status: 422\n\t\tend\t\n\tend",
"def index\n\t@transactions = current_user.transactions.all.order(created_at: :desc)\n\trender json: { transactions: @transactions }\nend",
"def index\n @vacations = User.find(params[:user_id]).vacations \n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @vacations }\n end\n end",
"def index\n @expenses = Expense.for_user(current_user).all\n @sum = Expense.for_user(current_user).sum(:price)\n \n respond_to do |format|\n format.html # index.html.erb\n format.iphone {render :layout => false}\n format.xml { render :xml => @expenses }\n end\n end",
"def index\n if User.count < 1\n @user = User.new\n @user.current_balance = 0.0\n @user.save\n else\n @user = User.all.first\n end\n @expense_this_week = Expense.where(:created_at => Time.now.beginning_of_week..Time.now, :gains => false).sum(\"amount\")\n @expense = Expense.new\n @category = Category.new\n category = Category.all\n @category_data = category.map{|c| [c.name,c.expenses.sum(\"amount\")]}.to_h\n @daily_expense_data = Expense.group_by_day(:created_at).sum(\"amount\")\n @expenses = Expense.paginate(:page => params[:page], :per_page => 10).where(:date => 30.days.ago..Time.now).order(\"date DESC\")\n end",
"def index\n @person_expense_records = PersonExpenseRecord.all\n\n render json: @person_expense_records\n end",
"def index\n @user = User.all\n # Users can view all debates\n @search = Debate.search(params[:q])\n # Seting up the search params\n @debates = @search.result\n # For the search functionality above.\n end",
"def index_invites\n puts \"user: #{@current_user.json_hash[:id]}\"\n dinners = []\n @dinners = @current_user.invited_dinners\n @dinners.each do |dinner|\n dinners << dinner.all_info\n end\n render json: dinners\n end",
"def index\n @deseases = Desease.order(:id)\n\n render json: @deseases\n end",
"def user_transactions\n user_deposits = get_user_deposits\n user_withdrawals = get_user_withdrawals\n json_response({:user_transactions => @user_transactions, :user_deposits => user_deposits, :user_withdrawals => user_withdrawals})\n end",
"def index\n @expenses = get_class.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @expenses }\n end\n end",
"def index\n @diaries = current_user.diaries.all\n respond_to do |format|\n format.html {render :index}\n format.json { render json: @diaries }\n end\n end",
"def index\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: UnpaidDebtsDatatable.new(view_context) }\n end\n end",
"def index_attending\n puts \"user: #{@current_user.json_hash[:id]}\"\n dinners = []\n @dinners = @current_user.attended_dinners\n @dinners.each do |dinner|\n dinners << dinner.all_info\n end\n render json: dinners\n end",
"def index\n @transactions = User.find(params[:id])\n end",
"def index\n @bills = @dwelling.bills\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @bills }\n end\n end",
"def index\n user_id = params[:user_id]\n user_id=current_user.user_id unless user_id.present?\n\n @fans = User.get_fans(user_id)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @fans }\n end\n end",
"def index\n users = User.all\n # cheer_ups = CheerUp.all\n render json: users\n end",
"def index\n @expenses = Expense.get_expenses(\n current_user[:id],\n session[:budget]['dateStart'],\n session[:budget]['dateEnd'],\n sort\n )\n\n get_tag_forms\n\n @expenses_sum = calculate_expenses_sum @expenses\n\n get_charts_and_tags @expenses\n end",
"def index\n @userfunds = Userfund.all\n end",
"def index\n @api_v1_expenses = Api::V1::Expense.all\n end",
"def index\n @wallet_id = params[:wallet_id]\n @investment_funds = InvestmentFund.where(\"wallet_id = ?\", @wallet_id)\n end",
"def index\n @deals = Deal.where(account_id: current_user.account_id)\n end",
"def index\n @travel_requests = TravelRequest.where user_id: current_user.id\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => @travel_requests }\n end\n end",
"def index\n @trades = Trade\n .only(:created_at, :is_fair, :ash_pokemons, :brock_pokemons)\n respond_to do |format|\n format.json { render json: @trades }\n end\n end",
"def index\n @decks = current_user.decks\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @decks }\n end\n end",
"def index\n @wallets = Wallet.all\n @user_life = current_seller.user_life\n end",
"def index\n @deposits = Deposit.all\n end",
"def index\n\n if (params[:dossier])\n if params[:dossier] && params[:clear].present? && params[:clear] == 'true'\n @expenses = []\n elsif params[:dossier] && params[:activite_id].present? && params[:activite_id]!='undefined' \n @expenses = Expense.where(:dossier_id => params[:dossier], :activite_id => params[:activite_id])\n else\n @expenses = Expense.where(:dossier_id => params[:dossier])\n end\n else\n @expenses = []\n end\n \n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @expenses }\n format.json {render :json => {\"success\"=>true,\"data\"=>@expenses.map {|p| p.attributes.merge(:total_ht => p.total, :total_ttc => p.total_ttc, :activite_name => p.activite.try(:description))}, :totalSize =>@expenses.count}}\n \n end\n end",
"def index\n @user = User.find(params[:user_id])\n @user_accounts = @user.user_accounts\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @user_accounts }\n format.xml { render xml: @user_accounts }\n end\n end",
"def index\n user_id = @user.id\n @auctions = Auction.where(\"seller_id = ?\", user_id)\n\n # get all belong auctions\n render json: @auctions\n end",
"def index\n @record_expenses = RecordExpense.all\n end",
"def index\n @transactions = current_user.transactions.order(date: :desc).limit(100)\n end",
"def index\n puts \"user: #{@current_user.json_hash[:id]}\"\n hosted_dinners = []\n attended_dinners = []\n @hosted_dinners = @current_user.hosted_dinners.where('starts_at >= ?', \"#{Time.now}\").order(starts_at: :asc).each do |dinner|\n hosted_dinners << dinner.all_info\n end\n @attended_dinners = @current_user.attended_dinners.where('starts_at >= ?', \"#{Time.now}\").order(starts_at: :asc).each do |dinner|\n attended_dinners << dinner.all_info\n end\n render json: {\n hosting: hosted_dinners,\n attending: attended_dinners\n }\n end",
"def index\n @depenses = Depense.all\n @total = 0\n @depenses.each do |dep|\n @total += dep.value\n end\n @solde = User.find(1).solde\n end",
"def index\n @items = Item.all\n @budget = Budget.find params[:budget_id]\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @items }\n end\n end",
"def index\n if params[:status]\n status = params[:status]\n else\n status = 0\n end\n @transactions = current_user.transactions.where(:status => status).paginate(page: params[:page], per_page: 5)\n @transactions_by_date = @transactions.group_by(&:deadline)\n @date = params[:date] ? Date.parse(params[:date]) : Date.today\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @transactions }\n end\n end",
"def index\n @transactions = current_user.wallet.transactions\n\n end",
"def index\n respond_to do |format|\n format.html # index.html.erb\n format.json {render :json => ExpenseDatatable.new(view_context, @company, @current_user, @financial_year) }\n end\n end",
"def index\n render :json => UserInterest.all\n end",
"def index\n @extended_warranties = ExtendedWarranty.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @extended_warranties }\n end\n end",
"def index\n @utility_expenses = UtilityExpense.all\n end",
"def index\n @trades = Trade.all\n render json: @trades\n end",
"def index\n @user_plants = UserPlant.where(user: current_user)\n render json: @user_plants,\n include: { plant: { only: [:name, :water, :light_indoors, :light_outdoors] } },\n except: [:updated_at, :created_at, :user_id]\n end",
"def index\n @transactions = Transaction.where('(lender_id = ? or debtor_id = ?)', current_user.id, current_user.id).order 'created_at DESC'\n end",
"def index\n @users = User.where(:apartamento_id => params[:apartamento_id])\n #@users = User.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @users }\n end\n end",
"def index\n @offenses = Offense.all\n end",
"def index\n #@items = Item.find_by_user_id(Session[user_id])\n @items = Item.all\n render json: @items\n end",
"def index\n @defenses = Defense.all\n end",
"def index\n @accountfinancials = Accountfinancial.where(user_id: current_user.id)\n end",
"def index\n @transactions = current_user.transactions\n end",
"def index\n @transactions = Transaction.all\n render json: @transactions\n end",
"def index\n @expenses = Expense.limit(10)\n\n respond_to do |format|\n format.html # index.html.erb\n format.xml { render :xml => @expenses }\n end\n end",
"def index\n user_coin_transactions = get_user_coin_transactions\n if user_coin_transactions\n json_response(user_coin_transactions)\n else \n json_response({:status => false, :message => 'no transaction'})\n end\n end",
"def index\n @investments = Investment.all\n\n render json: {investments: @investments}, root: false\n end",
"def index\n @rec_expenses = RecExpense.all\n end",
"def index\n @funds = Fund.all\n\n render json: @funds\n end",
"def index\n @accounting_items = Accounting::Item\n .where(user_id: @current_user.id)\n .includes(:type)\n .joins(:type)\n\n respond_to do |format|\n format.json { render json: @accounting_items, include: :type }\n end\n end",
"def index\n @expense_buddies = ExpenseBuddy.all\n end",
"def index\n @bills = current_user_or_guest.bills \\\n .includes(:user, participations: :person) \\\n .order(\"bills.date DESC, bills.created_at DESC\")\n\n respond_to do |format|\n format.html { @bills = @bills.decorate }\n format.xml { render xml: @bills }\n format.json { render json: @bills }\n end\n end",
"def index\n if @account\n @transactions = @account.transactions\n else\n @transactions = Transaction.all\n end\n render json: @transactions\n end",
"def index\n account = Account.find(params[:account_id].to_i)\n @transactions = account.transactions\n\n transactions_json = TransactionSerializer.new(@transactions).serialized_json\n render json: transactions_json\n end",
"def index\n @expenses = Expense.search(params[:search])\n end",
"def index\n @taxes = params['item_id'] ? Item.find(params['item_id']).taxes : Tax.all\n render json: @taxes\n end",
"def index\n redirect_to home_entries_path\n\n @entries = current_user.entries.expenses\n end",
"def index_user\n @tickets = Ticket.all_for_user(current_user.id)\n render json: @tickets, status: 200\n end",
"def index\n #@users = User.all\n @users = User.where(tenant_id: current_tenant.id)\n render json: {\n message: 'Your All Users',\n user: @users\n }\n end",
"def show\n @expense = Expense.find(params[:id])\n index\n end",
"def index\n @pledges = Pledge.where('user_id = ?', current_user.id)\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @pledges }\n end\n end",
"def index\n @stock_wastage_vouchers = @company.stock_wastage_vouchers.by_branch_id(@current_user.branch_id).by_date(@financial_year)\n respond_to do |format|\n format.html # index.html.erb\n format.json { render :json => StockTransferVoucherDatatable.new(view_context, @company, @current_user, @financial_year)}\n end\n end",
"def index\n if admin_signed_in?\n @transactions = Transaction.all\n else\n @transactions = Transaction.tri(@current_user.id).all\n end\n respond_to do |format|\n format.html\n format.json { render json: @transactions}\n end\n end",
"def index\n @nvs_dept_users = NvsDeptUser.all\n\n respond_to do |format|\n format.html # index.html.erb\n format.json { render json: @nvs_dept_users }\n end\n end",
"def index\n @bankdeposits = Bankdeposit.all\n end"
] |
[
"0.8071129",
"0.7704536",
"0.75661975",
"0.74813133",
"0.74079037",
"0.73860496",
"0.7382088",
"0.7296139",
"0.7250527",
"0.7234994",
"0.72144365",
"0.71990156",
"0.7157554",
"0.7133846",
"0.712324",
"0.7096128",
"0.7084539",
"0.7084539",
"0.7071406",
"0.707128",
"0.70526135",
"0.70279413",
"0.70254284",
"0.698316",
"0.696685",
"0.6957696",
"0.6957696",
"0.6957009",
"0.6952678",
"0.6946965",
"0.6934594",
"0.69317865",
"0.69138944",
"0.69027936",
"0.6892043",
"0.68916875",
"0.68872476",
"0.6866158",
"0.6854024",
"0.68533087",
"0.6853013",
"0.682305",
"0.68167967",
"0.681501",
"0.67968774",
"0.6781945",
"0.6778742",
"0.67686224",
"0.67567515",
"0.67513925",
"0.6746893",
"0.6741326",
"0.67352796",
"0.6732256",
"0.6725831",
"0.67214906",
"0.67137414",
"0.67105484",
"0.6697564",
"0.6693324",
"0.6690851",
"0.66864556",
"0.6685744",
"0.66722775",
"0.66619956",
"0.66578877",
"0.6657043",
"0.66511273",
"0.66399246",
"0.6637366",
"0.6629538",
"0.6628026",
"0.6618943",
"0.6614549",
"0.6613034",
"0.66050285",
"0.6600917",
"0.66006184",
"0.6598106",
"0.6596905",
"0.6585315",
"0.65827465",
"0.6578863",
"0.65748495",
"0.65704745",
"0.65623057",
"0.65620387",
"0.6556727",
"0.65557265",
"0.65548545",
"0.6553908",
"0.65385497",
"0.65257984",
"0.652473",
"0.65234166",
"0.6520943",
"0.65207344",
"0.6507425",
"0.6506249",
"0.65056133"
] |
0.6620122
|
72
|
options: key: namespace name redis_prefix: redis prefix name similarity_func: see readme.md file weight: see readme.md file
|
def initialize(options)
@input_matrix = Recommendify::InputMatrix.create(options)
@similarity_matrix = Recommendify::SimilarityMatrix.new(options)
end
|
{
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
}
|
[
"def redis_key(str)\n \"score:#{self.id}:#{str}\"\n end",
"def add_item_to_redis_key args, key\n if args.has_key?(key) && !args[key].nil?\n key = \":#{args[key]}\"\n key = key.mb_chars.downcase if redis_key_normalize_conf.include?(:downcase)\n key = ActiveSupport::Inflector::transliterate(key) if redis_key_normalize_conf.include?(:transliterate)\n key \n else\n \":*\"\n end\n end",
"def get_cached_similarity_for(item1, item2)\n @cached_similarities[\"#{item1}_#{item2}\"] || @cached_similarities[\"#{item2}_#{item1}\"]\n end",
"def redis_prefix\n @redis_prefix ||= name.underscore\n end",
"def add_random_ratio_to_redis\n self.random_ratio_from_redis[self.id] = random_ratio\n end",
"def initialize(name)\n @redis_key = name\n end",
"def initialize(key, options = {})\n @key = sanitize_key(key)\n @default = options[:default]\n @options = options\n @on_change = options[:on_change]\n\n if @default && !redis.exists(self.key)\n redis.set key, self.class.cast_to_redis(@default, @options)\n end\n end",
"def call\n raise ArgumentError.new(\"'key' must be an instance of String!\") unless context.key.instance_of?( String )\n Redis.current.sadd( STATS_KEY_SET_NAME, context.key )\n end",
"def [](key)\n redis.zscore(@redis_key, key)\n end",
"def method_missing(method_symbol, *args, &blk)\n redis.send(method_symbol, *args, &blk)\n end",
"def initialize key, redis, options = {}\n @key = key\n @redis = redis\n @limit = options[:limit] || 50\n @interval = options[:interval] || 60\n end",
"def using(options = {})\n merged = Ramaze::Cache::Redis.trait[:default].merge(options)\n Class.new(self) { @options = merged }\n end",
"def redisize_model value, options = {}, &block\n primary_key = options.fetch(:by_key, self.primary_key).to_s\n key = [\"instance\", name, primary_key, value]\n metakey = [\"meta\", self.model_name.name, primary_key, value]\n\n # binding.pry\n Rails.cache.fetch(key, expires_in: 1.week) do\n if result = block.call\n Redisable.enqueue(:redisize_model_metas, metakey, self.name, Redisable.as_json_for(result), key)\n end\n\n result\n end\n end",
"def _key(*args); args.hash; end",
"def call\n @from_redis.scan_each(match: \"*\", count: FeatureFlagger::Storage::Redis::SCAN_EACH_BATCH_SIZE) do |redis_key|\n # filter out resource_keys\n next if redis_key.start_with?(\"#{FeatureFlagger::Storage::Redis::RESOURCE_PREFIX}:\")\n\n migrate_key(redis_key)\n end\n end",
"def rekey_as_needed; end",
"def similarity(user1,user2)\n user1,user2=user2,user1 if user1 > user2\n result=@similarity_cache[[user1,user2]]\n if result.nil?\n result=@similarity_func.call(data,user1,user2)\n @similarity_cache[[user1,user2]]=result\n end\n result\n end",
"def redis_key\n self.class.redis_key(@name)\n end",
"def update_similarities_for_(user_id)\n user_id = user_id.to_s # For comparison. Redis returns all set members as strings.\n similarity_set = Recommendable::Helpers::RedisKeyMapper.similarity_set_for(user_id)\n\n Recommendable.set_shard_key user_id\n\n # Only calculate similarities for users who have rated the items that\n # this user has rated\n relevant_user_ids = Recommendable.config.ratable_classes.inject([]) do |memo, klass|\n liked_set = Recommendable::Helpers::RedisKeyMapper.liked_set_for(klass, user_id)\n disliked_set = Recommendable::Helpers::RedisKeyMapper.disliked_set_for(klass, user_id)\n\n item_ids = Recommendable.redis.sunion(liked_set, disliked_set)\n\n unless item_ids.empty?\n sets = item_ids.map do |id|\n liked_by_set = Recommendable::Helpers::RedisKeyMapper.liked_by_set_for(klass, id)\n disliked_by_set = Recommendable::Helpers::RedisKeyMapper.disliked_by_set_for(klass, id)\n\n [liked_by_set, disliked_by_set]\n end\n\n memo | Recommendable.redis.sunion(*sets.flatten)\n else\n memo\n end\n end\n\n similarity_values = relevant_user_ids.map { |id| similarity_between_(user_id, id) }\n Recommendable.redis.pipelined do\n relevant_user_ids.zip(similarity_values).each do |id, similarity_value|\n next if id == user_id # Skip comparing with self.\n Recommendable.redis.zadd(similarity_set, similarity_value, id)\n end\n end\n\n if knn = Recommendable.config.nearest_neighbors\n length = Recommendable.redis.zcard(similarity_set)\n kfn = Recommendable.config.furthest_neighbors || 0\n\n Recommendable.redis.zremrangebyrank(similarity_set, kfn, length - knn - 1)\n end\n\n true\n end",
"def redis_pool; end",
"def zscore(key, member); end",
"def zscore(key, member); end",
"def similarity_to(other,options={})\n shared_words = shared_words_with(other,options)\n shared_words.length * 2.0 / (words.length + other.words.length)\n end",
"def redis_key(str)\n \"user:#{self.id}:#{str}\"\n end",
"def query(metric_name, options={})\n key = build_key(metric_name)\n parse_time_range(options)\n key << assemble_for(options)\n if options[:id]\n key = \"dnid:#{options[:id]}\"\n real_key = DulyNoted.redis.get key\n if options[:meta_fields]\n options[:meta_fields].collect! { |x| x.to_s }\n result = {}\n options[:meta_fields].each do |field|\n result[field] = DulyNoted.redis.hget real_key, field\n end\n results = [result]\n else\n results = [DulyNoted.redis.hgetall(real_key)]\n end\n else\n keys = find_keys(key)\n grab_results = Proc.new do |metric|\n if options[:meta_fields]\n options[:meta_fields].collect! { |x| x.to_s }\n result = {}\n options[:meta_fields].each do |field|\n result[field] = DulyNoted.redis.hget metric, field\n end\n result\n else\n DulyNoted.redis.hgetall metric\n end\n end\n results = []\n if options[:time_start] && options[:time_end]\n keys.each do |key|\n results += DulyNoted.redis.zrangebyscore(key, options[:time_start].to_f, options[:time_end].to_f).collect(&grab_results)\n end\n else\n keys.each do |key|\n results += DulyNoted.redis.zrange(key, 0, -1).collect(&grab_results)\n end\n end\n end\n return results\n end",
"def testit(filename)\n r = Redis.new\n r.config(\"SET\",\"maxmemory\",\"2000000\")\n if $o[:ttl]\n r.config(\"SET\",\"maxmemory-policy\",\"volatile-ttl\")\n else\n r.config(\"SET\",\"maxmemory-policy\",\"allkeys-lru\")\n end\n r.config(\"SET\",\"maxmemory-samples\",5)\n r.config(\"RESETSTAT\")\n r.flushall\n\n html = \"\"\n html << <<EOF\n <html>\n <body>\n <style>\n .box {\n width:5px;\n height:5px;\n float:left;\n margin: 1px;\n }\n\n .old {\n border: 1px black solid;\n }\n\n .new {\n border: 1px green solid;\n }\n\n .otherdb {\n border: 1px red solid;\n }\n\n .ex {\n background-color: #666;\n }\n </style>\n <pre>\nEOF\n\n # Fill the DB up to the first eviction.\n oldsize = r.dbsize\n id = 0\n while true\n id += 1\n begin\n r.set(id,\"foo\")\n rescue\n break\n end\n newsize = r.dbsize\n break if newsize == oldsize # A key was evicted? Stop.\n oldsize = newsize\n end\n\n inserted = r.dbsize\n first_set_max_id = id\n html << \"#{r.dbsize} keys inserted.\\n\"\n\n # Access keys sequentially, so that in theory the first part will be expired\n # and the latter part will not, according to perfect LRU.\n\n if $o[:ttl]\n STDERR.puts \"Set increasing expire value\"\n (1..first_set_max_id).each{|id|\n r.expire(id,1000+id)\n STDERR.print(\".\") if (id % 150) == 0\n }\n else\n STDERR.puts \"Access keys sequentially\"\n (1..first_set_max_id).each{|id|\n r.get(id)\n sleep 0.001\n STDERR.print(\".\") if (id % 150) == 0\n }\n end\n STDERR.puts\n\n # Insert more 50% keys. We expect that the new keys will rarely be expired\n # since their last access time is recent compared to the others.\n #\n # Note that we insert the first 100 keys of the new set into DB1 instead\n # of DB0, so that we can try how cross-DB eviction works.\n half = inserted/2\n html << \"Insert enough keys to evict half the keys we inserted.\\n\"\n add = 0\n\n otherdb_start_idx = id+1\n otherdb_end_idx = id+100\n while true\n add += 1\n id += 1\n if id >= otherdb_start_idx && id <= otherdb_end_idx\n r.select(1)\n r.set(id,\"foo\")\n r.select(0)\n else\n r.set(id,\"foo\")\n end\n break if r.info['evicted_keys'].to_i >= half\n end\n\n html << \"#{add} additional keys added.\\n\"\n html << \"#{r.dbsize} keys in DB.\\n\"\n\n # Check if evicted keys respect LRU\n # We consider errors from 1 to N progressively more serious as they violate\n # more the access pattern.\n\n errors = 0\n e = 1\n error_per_key = 100000.0/first_set_max_id\n half_set_size = first_set_max_id/2\n maxerr = 0\n (1..(first_set_max_id/2)).each{|id|\n if id >= otherdb_start_idx && id <= otherdb_end_idx\n r.select(1)\n exists = r.exists(id)\n r.select(0)\n else\n exists = r.exists(id)\n end\n if id < first_set_max_id/2\n thiserr = error_per_key * ((half_set_size-id).to_f/half_set_size)\n maxerr += thiserr\n errors += thiserr if exists\n elsif id >= first_set_max_id/2\n thiserr = error_per_key * ((id-half_set_size).to_f/half_set_size)\n maxerr += thiserr\n errors += thiserr if !exists\n end\n }\n errors = errors*100/maxerr\n\n STDERR.puts \"Test finished with #{errors}% error! Generating HTML on stdout.\"\n\n html << \"#{errors}% error!\\n\"\n html << \"</pre>\"\n $runs << errors\n\n # Generate the graphical representation\n (1..id).each{|id|\n # Mark first set and added items in a different way.\n c = \"box\"\n if id >= otherdb_start_idx && id <= otherdb_end_idx\n c << \" otherdb\"\n elsif id <= first_set_max_id\n c << \" old\"\n else\n c << \" new\"\n end\n\n # Add class if exists\n if id >= otherdb_start_idx && id <= otherdb_end_idx\n r.select(1)\n exists = r.exists(id)\n r.select(0)\n else\n exists = r.exists(id)\n end\n\n c << \" ex\" if exists\n html << \"<div title=\\\"#{id}\\\" class=\\\"#{c}\\\"></div>\"\n }\n\n # Close HTML page\n\n html << <<EOF\n </body>\n </html>\nEOF\n\n f = File.open(filename,\"w\")\n f.write(html)\n f.close\nend",
"def set_similarity_cache_for(item1, item2, sim)\n @cached_similarities[\"#{item1}_#{item2}\"] = sim\n end",
"def resident_key=(_arg0); end",
"def dns_find(key)\n \n end",
"def populate_keys(node, keys, size)\n f = IO.popen(\"redis-cli -h #{node[:host]} -p #{node[:port]} -n #{node[:db]} --pipe\", IO::RDWR)\n\n keys.each do |key|\n size.times.map do |x| \n f << to_redis_proto('SADD', key, ::Digest::MD5.hexdigest('f' + x.to_s))\n end\n end\n\n f.close\n end",
"def method_missing method, *arguments, &blk\n if redis.respond_to?(method)\n # If its a method available to redis just pass it along with the key\n # as the first argument\n redis.__send__(method,key,*arguments,&blk)\n else\n # If redis responds to the method prefixed with an h pass it along\n if method.to_s[0] != 'h' && (new_method = \"h#{method}\") && redis.respond_to?(new_method)\n self.send(new_method,*arguments,&blk)\n else\n super\n end\n end\n end",
"def score_redis\n case tipo.estandariza\n when 'estado'\n 1000\n when 'municipio'\n 100\n when 'anp'\n 10\n end\n end",
"def exchange_keys; end",
"def exchange_keys; end",
"def cache_setup(hostname, username, appname, cachename)\n options[:namespace] = [\n 'ramaze', hostname, username, appname, cachename\n ].compact.join(':')\n redis_connection = ::Redis.new\n @client = ::Redis::Namespace.new(options[:namespace], redis: redis_connection)\n end",
"def cache_setup(*args)\n opts = options.dup\n opts[:prefix] = ['ramaze', *args].compact.join(':')\n opts[:expires] = opts.delete(:expires_in)\n adapter = opts.delete(:adapter)\n @moneta = ::Moneta.new(adapter, options)\n end",
"def redis_alias_key alias_name \n self.class.generate_alias_key(alias_name, to_arg)\n end",
"def redis_key(str)\n \"user:#{self.id}:#{str}\"\n end",
"def pttl(key); end",
"def pttl(key); end",
"def redis_hash(name)\n name.to_s.singularize\n instance_eval <<-RUBY\n def reset_#{name.to_s.pluralize}\n keys = RedisRecord.redis.keys(key(\"#{name}\") + \"/*\")\n skeys = RedisRecord.redis.keys(key(\"summed_#{name}\") + \"/*\")\n\n RedisRecord.redis.del(*keys) unless keys.blank?\n RedisRecord.redis.del(*skeys) unless skeys.blank?\n end\n RUBY\n\n class_eval <<-RUBYI\n def delete_#{name.to_s.singularize}(track_id)\n k = key(\"#{name.to_s}/\") + id.to_s\n RedisRecord.redis.zrem(k, track_id)\n\n j = key(\"summed_#{name.to_s}/\") + id.to_s\n RedisRecord.redis.zrem(j, track_id)\n end\n\n def record_#{name.to_s.singularize}(track_id)\n k = key(\"#{name.to_s}/\") + id.to_s\n RedisRecord.redis.zadd(k, 1, track_id)\n end\n\n def #{name}\n k = key(\"#{name.to_s}/\") + id.to_s\n RedisRecord.redis.zrevrange(k, 0, -1)\n end\n\n def summed_#{name}(page=1, num_records=20)\n page = page.to_i <= 1 ? 1 : page.to_i\n start = (page - 1) * num_records\n stop = start + num_records - 1\n\n k = key(\"summed_#{name.to_s}/\") + id.to_s\n RedisRecord.\n redis.\n zrevrange(k, start, stop, :with_scores => true).\n each_slice(2).\n to_a\n end\n\n def replace_summed_#{name}(other_ids)\n k = key(\"summed_#{name.to_s}/\") + id.to_s\n if other_ids.empty?\n other_ids << -1\n\t\t other_keys = other_ids.map {|i| key(\"#{name.to_s}/\") + i.to_s}\n\t\t RedisRecord.redis.zunionstore(k, other_keys)\n\t\t else \n\t\t other_keys = other_ids.map {|i| key(\"#{name.to_s}/\") + i.to_s}\n\t\t RedisRecord.redis.zunionstore(k, other_keys)\n\t\t end \n end\n\n def reset_#{name}\n RedisRecord.redis.del(key(\"#{name}/\\#{id}\")) rescue nil\n end\n RUBYI\n end",
"def once_run(key, options = {})\n raise ArgumentError unless key\n\n if key.kind_of? Array\n raise ArgumentError unless key.flatten.all?\n key = key.join(\"/\")\n end\n\n options = {\n expires_in: 1.hours,\n }.merge(options)\n\n # https://qiita.com/shiozaki/items/b746dc4bb5e1e87c0528\n values = redis.multi do\n redis.incr(key)\n redis.expire(key, options[:expires_in])\n end\n\n counter = values.first\n\n Rails.logger.debug([__method__, {key: key, counter: counter, expires_in: redis.ttl(key)}])\n\n counter == 1\n end",
"def lua_load\n functions = %q(\n local functions = {}\n functions.check = function(key, entries, precision, data)\n local keyct = key .. ':count'\n local index = redis.call('GET', keyct)\n if not index then\n return 0\n end\n index = math.ceil(index / entries)\n local hash = redis.sha1hex(data)\n local h = { }\n h[0] = tonumber(string.sub(hash, 0 , 8 ), 16)\n h[1] = tonumber(string.sub(hash, 8 , 16), 16)\n h[2] = tonumber(string.sub(hash, 16, 24), 16)\n h[3] = tonumber(string.sub(hash, 24, 32), 16)\n local maxk = math.floor(0.693147180 * math.floor((entries * math.log(precision * math.pow(0.5, index))) / -0.480453013) / entries)\n local b = { }\n for i=1, maxk do\n table.insert(b, h[i % 2] + i * h[2 + (((i + (i % 2)) % 4) / 2)])\n end\n for n=1, index do\n local key = key .. ':' .. n\n local found = true\n local bits = math.floor((entries * math.log(precision * math.pow(0.5, n))) / -0.480453013)\n local k = math.floor(0.693147180 * bits / entries)\n\n for i=1, k do\n if redis.call('GETBIT', key, b[i] % bits) == 0 then\n found = false\n break\n end\n end\n\n if found then\n return 1\n end\n end\n\n return 0\n end\n\n functions.set = function(key, entries, precision, data, set_value)\n local index = math.ceil(redis.call('INCR', key .. ':count') / entries)\n local key = key .. ':' .. index\n local bits = math.floor(-(entries * math.log(precision * math.pow(0.5, index))) / 0.480453013)\n local k = math.floor(0.693147180 * bits / entries)\n local hash = redis.sha1hex(data)\n local h = { }\n h[0] = tonumber(string.sub(hash, 0 , 8 ), 16)\n h[1] = tonumber(string.sub(hash, 8 , 16), 16)\n h[2] = tonumber(string.sub(hash, 16, 24), 16)\n h[3] = tonumber(string.sub(hash, 24, 32), 16)\n for i=1, k do\n redis.call('SETBIT', key, (h[i % 2] + i * h[2 + (((i + (i % 2)) % 4) / 2)]) % bits, set_value)\n end\n return 1\n end\n\n functions.setnx = function(key, entries, precision, data, set_value)\n if functions.check(key, entries, precision, data) ~= 1 then\n functions.set(key, entries, precision, data, set_value)\n return 1\n else\n return 0\n end\n end\n\n local function invoke(f, ...)\n return functions[f](KEYS[1], ...)\n end\n\n return invoke(unpack(ARGV))\n )\n\n @functions_sha = Digest::SHA1.hexdigest(functions)\n\n loaded = @redis.script(:exists, [@functions_sha]).uniq\n if loaded.count != 1 || loaded.first != true\n @functions_sha = @redis.script(:load, functions)\n end\n end",
"def redis=(server)\n if server.is_a? String\n if server =~ /redis\\:\\/\\//\n redis = Redis.connect(:url => server)\n else\n server, namespace = server.split('/', 2)\n host, port, db = server.split(':')\n redis = Redis.new(:host => host, :port => port,\n :thread_safe => true, :db => db)\n end\n namespace ||= :related\n @redis = Redis::Namespace.new(namespace, :redis => redis)\n elsif server.respond_to? :namespace=\n @redis = server\n else\n @redis = Redis::Namespace.new(:related, :redis => server)\n end\n end",
"def get key\n @redis.get key\n end",
"def redis_pool=(_arg0); end",
"def generate_redis_connection!\n redis_options ? Redis.new(**redis_options) : Redis.current\n end",
"def update_similarities_for(user_id)\n user_id = user_id.to_s # For comparison. Redis returns all set members as strings.\n similarity_set = Recommendable::Helpers::RedisKeyMapper.similarity_set_for(user_id)\n\n # Only calculate similarities for users who have rated the items that\n # this user has rated\n relevant_user_ids = Recommendable.config.ratable_classes.inject([]) do |memo, klass|\n gemd_set = Recommendable::Helpers::RedisKeyMapper.gemd_set_for(klass, user_id)\n disgemd_set = Recommendable::Helpers::RedisKeyMapper.disgemd_set_for(klass, user_id)\n\n item_ids = Recommendable.redis.sunion(gemd_set, disgemd_set)\n\n unless item_ids.empty?\n sets = item_ids.map do |id|\n gemd_by_set = Recommendable::Helpers::RedisKeyMapper.gemd_by_set_for(klass, id)\n disgemd_by_set = Recommendable::Helpers::RedisKeyMapper.disgemd_by_set_for(klass, id)\n\n [gemd_by_set, disgemd_by_set]\n end\n\n memo | Recommendable.redis.sunion(*sets.flatten)\n else\n memo\n end\n end\n\n relevant_user_ids.each do |id|\n next if id == user_id # Skip comparing with self.\n Recommendable.redis.zadd(similarity_set, similarity_between(user_id, id), id)\n end\n\n if knn = Recommendable.config.nearest_neighbors\n length = Recommendable.redis.zcard(similarity_set)\n kfn = Recommendable.config.furthest_neighbors || 0\n\n Recommendable.redis.zremrangebyrank(similarity_set, kfn, length - knn - 1)\n end\n\n true\n end",
"def redis_on_base\n on_base\n end",
"def hash_key(key, options = T.unsafe(nil)); end",
"def key_requeues\n key(\"requeues\")\n end",
"def cache_key(id); end",
"def key_matcher(pattern, options)\n prefix = options[:namespace].is_a?(Proc) ? options[:namespace].call : options[:namespace]\n\n pattern = pattern.inspect[1..-2] if pattern.is_a? Regexp\n\n if prefix\n \"#{prefix}:#{pattern}\"\n else\n pattern\n end\n end",
"def test(similarity=\"pearson\",aggregation=\"weight_average\",k=nil)\n data = MovieData.new\n data.load_data('ml-100k',:u1) \n puts (time do\n p = Predicter.new(data,Similarity.method(similarity),Aggregation.method(aggregation))\n puts p.run_test(k).inspect\n end)\nend",
"def initialize api_name, redis, options\n @namespace = api_name.strip.downcase.gsub(/[-\\s]+/,'_')\n @redis = redis\n\n @hits_per_session = options.fetch :hits_per_session do\n raise ArgumentError, \"Must supply :hits_per_session\"\n end\n\n @cooldown = options.fetch :cooldown do\n raise ArgumentError, \"Must supply :cooldown\"\n end\n\n # Process method limits as a proportion of total hits.\n # If no methods are limited, each has the complete quota available.\n @method_limits = Hash.new @hits_per_session\n if options[:method_limits]\n options[:method_limits].each do |method, proportion|\n @method_limits[method] = (@hits_per_session * proportion).floor\n end\n end\n end",
"def key_matcher(pattern, options); end",
"def initialize(data,similarity,aggregation)\n @data=data\n @similarity_func=similarity\n @aggregation_func=aggregation\n @similarity_cache={}\n end",
"def initialize(redis, options={})\n\n if options == {} && redis.is_a?(Hash)\n\n redis_options, options = redis.partition { |k, v|\n REDIS_OPTIONS.include?(k.to_s)\n }\n\n redis_options = Hash[redis_options]\n options = Hash[options]\n\n redis_options = redis_options.inject({}) { |h, (k, v)|\n h[k.to_sym] = v;\n h\n }\n\n redis = ::Redis.new(redis_options)\n end\n\n @redis = redis\n @options = options\n\n # Returns an array of the (String) keys that match the given pattern.\n #\n # Returns an empty array if anything goes wrong.\n #\n def @redis.keys_to_a(pattern)\n\n if (a = (keys(pattern) rescue nil)).is_a?(Array)\n a\n else\n []\n end\n end\n\n replace_engine_configuration(options)\n end",
"def zmscore(key, *members); end",
"def zmscore(key, *members); end",
"def movies_liked\n REDIS.smembers movies_liked_key\n end",
"def extra_keys(options, recall = T.unsafe(nil)); end",
"def migrate_key(node, key, options)\n begin\n if Redis::VERSION > '3.0.4'\n node.migrate(key, options)\n else\n node.migrate([options[:host], options[:port], key, options[:db], options[:timeout]])\n end\n rescue Redis::CommandError => e\n if e.message =~ TARGET_KEY_BUSY_REGEX\n # TODO check the value is correct, and delete the key from the old host\n # This might be better to be done by humans\n raise \"key #{key}: Target key busy!\"\n else\n raise e\n end\n end\n end",
"def redis\n @redis ||= (self['redis'] || {}).symbolize_keys\n end",
"def key=(_arg0); end",
"def key=(_arg0); end",
"def key=(_arg0); end",
"def sinterstore!(*other_keys)\n redis_client.sinterstore(key, *other_keys)\n end",
"def redis_set_options\n {}\n end",
"def initialize options={}\n # set defaults\n @env = options[:env] || 'default'\n @app = options[:app] || 'default'\n @verbose = options[:verbose].nil? ? true : options[:verbose]\n @subscribe_to_changes = options[:subscribe_to_changes].nil? ? true : options[:subscribe_to_changes]\n @cache_locally = options[:cache_locally].nil? ? true : options[:cache_locally]\n\n redis_options = options[:redis] || {}\n\n @prefix = redis_options[:prefix] || 'redfig'\n\n @local_cache = {}\n\n puts \"- Initializing Redis client with settings: #{redis_options.inspect}\" if @verbose\n\n @redis = Redis.new redis_options\n end",
"def key_matcher(pattern, options) # :doc:\n prefix = options[:namespace].is_a?(Proc) ? options[:namespace].call : options[:namespace]\n if prefix\n source = pattern.source\n if source.start_with?(\"^\")\n source = source[1, source.length]\n else\n source = \".*#{source[0, source.length]}\"\n end\n Regexp.new(\"^#{Regexp.escape(prefix)}:#{source}\", pattern.options)\n else\n pattern\n end\n end",
"def key(uri, options)\n [self.class.name, uri]\n end",
"def cache_key(search_string)\n \"_key_#{search_string}\"\n end",
"def get(key)\n shard_for(key).find_by(distkey => key)\n end",
"def similarity(user1, user2)\n\n user1 = user1.to_s\n user2 = user2.to_s\n \n weight_num = 0.20\n weight_movies = 0.40\n weight_rating = 0.40\n \n user1_num_movies = @user_database[user1].length\n user2_num_movies = @user_database[user2].length\n score_num_movies = ((user1_num_movies + user2_num_movies).to_f / ([user1_num_movies, user2_num_movies].max * 2)) * 100.0 \n \n #hash consists of movieID(string) => rating(float)\n user1_hash = {}\n user2_hash = {} \n @user_database[user1].each do |movieID, rating, time|\n user1_hash[movieID] = rating.to_f\n end\n @user_database[user2].each do |movieID, rating, time|\n user2_hash[movieID] = rating.to_f\n end \n common_movies = user1_hash.keys & user2_hash.keys\n num_common_movies = common_movies.length\n score_common_movies = (num_common_movies / [user1_hash.keys.length, user2_hash.keys.length].max ) * 100.0\n \n rating_difference = 0\n common_movies.each do |movieID|\n rating_difference += (user1_hash[movieID] - user2_hash[movieID]).abs\n end\n \n #in case of num_common_movies being 0, then penalize the rating score by 100\n if num_common_movies == 0\n avg_rating_diff = 100 \n else\n avg_rating_diff = rating_difference / num_common_movies.to_f\n end\n \n score_rating = 100 - avg_rating_diff\n \n similarity_score = (weight_num * score_num_movies + weight_movies * score_common_movies + weight_rating * score_rating)\n \n return similarity_score\n \n end",
"def namespace(key)\n if @namespace\n yield interpolate(key)\n else\n # This Redis::Store instance does not use a namespace so we should\n # just pass through the key.\n yield key\n end\n end",
"def build_similarity_cache\n similar = Note.find_similar_raw(self)\n Note.memoize(self,similar,self.user_id)\n end",
"def redis_key(str)\n \"leader_board:#{self.id}:#{str}\"\n end",
"def keygens; end",
"def redis_key_for(id)\n \"#{redis_prefix}:#{Array(id).join(':')}\"\n end",
"def initialize(options = {})\n self.class.options ||=\n Ramaze::Cache::Redis.trait[:default].merge(options)\n\n @options = options.merge(self.class.options)\n end",
"def score(member)\n conn.zscore(key, member)\n end",
"def redis_key(str)\n \"user:#{self.id}:#{str}\"\n end",
"def initialize options={}\n require 'redis'\n begin\n require 'redis-namespace'\n rescue LoadError\n require 'redis/namespace'\n end\n @redis = Redis.new(options)\n @namespace = options[:namespace] || 'graphiterb'\n @accumulators = Redis::Namespace.new(namespace, :redis => @redis)\n @regexp = options[:regexp] || /.*/\n @report_timestamp_key = options[:report_timestamp_key] || '_last_report_timestamp_'\n super('fake_scope', options) # FIXME shouldn't have to use a fake scope\n end",
"def key_for_cached\n [ @options[:namespace], MD5.hexdigest(@url) ].join('_')\n end",
"def initialize(options = {})\n url = options.delete(:url) { determine_redis_provider }\n namespace = options.delete(:namespace)\n driver = options.delete(:driver)\n @redis_connection = initialize_conection(url, namespace, driver)\n @redis_client = @redis_connection.client\n @redis_connection\n end",
"def getredisproto(*args)\n proto = [] \n proto.push(\"*\"+args.length.to_s+\"\\r\\n\")\n args.each{|arg|\n proto.push(\"$\"+arg.to_s.bytesize.to_s+\"\\r\\n\")\n proto.push(arg.to_s+\"\\r\\n\")\n }\n proto\nend",
"def test_set_key_unless_it_exists\n # Given\n refute @redis.exists( @key )\n\n # When\n @redis.set @key, @val1, nx: true\n\n # Then \n assert_equal @val1, @redis.get( @key )\n\n # ...and...\n\n # When\n @redis.set @key, @val2, nx: true\n\n # Then \n refute_equal @val2, @redis.get( @key )\n assert_equal @val1, @redis.get( @key )\n end",
"def ttl(key)\n key = add_namespace(key)\n @redis.ttl(key)\n end",
"def keys_for(host, options = T.unsafe(nil)); end",
"def scard(key); end",
"def scard(key); end",
"def graphite(prefix, key, value)\n # Curerent time\n epoch = Time.now.to_i\n\n # Test for value which is 0. Print if options[:verbose]\n if value == 0\n puts prefix + \".\" + key + \" \" + value.to_s + \" \" + epoch.to_s if @verbose\n else\n puts prefix + \".\" + key + \" \" + value.to_s + \" \" + epoch.to_s\n end\nend",
"def ttl(key); end",
"def ttl(key); end",
"def [](*args)\n args = args.first if (args.size == 1)\n return super(args) if args.is_a?(Hash)\n ck = cache_key(args)\n if obj = @cache_store.get(ck)\n return obj\n end\n if obj = super(args)\n @cache_store.set(ck, obj, @cache_ttl)\n end \n obj\n end",
"def delete_random_ratio_from_redis\n self.random_ratio_from_redis.delete self.id\n end",
"def rekey_limit; end",
"def resident_key; end",
"def initialize\n @redis = Redis.new(host: 'redis', port: 6379)\n end",
"def initialize\n @db_size = 10 # Number of puns to parse\n @db = Redis.new\n end"
] |
[
"0.59889215",
"0.56199765",
"0.5440855",
"0.54006696",
"0.53479666",
"0.5303104",
"0.5281439",
"0.5274622",
"0.5254971",
"0.5232295",
"0.5222194",
"0.51854455",
"0.51823235",
"0.5162396",
"0.51604503",
"0.5156732",
"0.5151567",
"0.5121496",
"0.5117017",
"0.51167166",
"0.51023525",
"0.51023525",
"0.5092688",
"0.5090886",
"0.50904405",
"0.50378066",
"0.50296414",
"0.5015282",
"0.50134313",
"0.5012297",
"0.4988928",
"0.49874857",
"0.497026",
"0.497026",
"0.4963719",
"0.4957167",
"0.49443784",
"0.49422327",
"0.49398422",
"0.49398422",
"0.49364403",
"0.493178",
"0.4899895",
"0.48852488",
"0.48818725",
"0.4881488",
"0.48661926",
"0.48493335",
"0.48477155",
"0.48472825",
"0.48453915",
"0.48438805",
"0.48416296",
"0.4831226",
"0.48285004",
"0.48265767",
"0.48230404",
"0.48219714",
"0.48110786",
"0.48110786",
"0.48098314",
"0.48093778",
"0.48080647",
"0.4807666",
"0.48017976",
"0.48017976",
"0.48017976",
"0.4798253",
"0.4796204",
"0.47941136",
"0.4784293",
"0.4781522",
"0.47810692",
"0.47806925",
"0.47775704",
"0.47481367",
"0.47475803",
"0.47418672",
"0.4731427",
"0.47287592",
"0.47286078",
"0.47192508",
"0.47131243",
"0.47085157",
"0.47009942",
"0.4700831",
"0.46875542",
"0.46873286",
"0.4683421",
"0.46805343",
"0.467717",
"0.467717",
"0.4673868",
"0.46678466",
"0.46678466",
"0.4666168",
"0.4662315",
"0.46573243",
"0.46483845",
"0.4646623",
"0.46464413"
] |
0.0
|
-1
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.