Chris Oliver

Pros are you get a lot of helpers for making basic forms quicker, downside is that I often customize my forms a lot so you can't really use their helpers all the time and it's also another API to continuously memorize. I use them in things like Admin areas or forms that don't need much UI work, but other than that, I tend to just use the normal form helpers and tags.

Check out this episode! https://gorails.com/episodes/forum-nested-attributes-and-fields-for It covers how to do that with the form and params in order to properly set everything up.

Aww that sucks. Keep us posted on how it goes. I'll have to do a more in-depth episode for this stuff. Some of those themes can be really, really complex. They basically market the theme as having absolutely any feature you can imagine, but that ends up with a seriously messy theme.

Yep of course! The same reason that you have to build your own controllers and views with mailboxer is the same reason why it will work perfectly with ActionCable. It really just handles the database side of things, which ties in perfectly with ActionCable. You'll still need to build the channels and everything, but it should work without a problem. Going to be covering this in a future episode as well.

I actually just continue hitting escape. It's a bit easier to reach on the Mac keyboard, so I haven't remapped it. I know a lot of people will play around with replacing caps lock for things like that or the leader key.

The thing about these gems is that they're probably quite simple if they're parsing out hashtags. Not too much to it which is nice and means they probably don't need a lot of maintenance.

I actually have never used any, but if you do end up using one, I'd love to hear how it goes!

If you need an admin to create other users, you can make a new controller that only the admin can access to create the other users. I would recommend using devise_invitable to send invitiations to those users. This sort of setup would let you add other users and set their roles. You can then authorize this controller to only allow admins to add users.

# You don't want this to conflict with devise URLs, so we namespace it
namespace :settings do
  routes :users
end

class Settings::UsersController < ApplicationController
  def create
    User.invite!(user_params)
  end

  private

    def user_params
      params.require(:user).permit(:email, :role)
    end
end

This sounds like a good use case for just a single User model with roles. Everyone can login from the same spot and then based upon their role, they can access various different things. The benefit of doing roles is that you can easily re-assign people jobs rather than having them have separate accounts to login with each time.

I haven't done an episode on this (yet!) but Rolify is a pretty good starting point unless you want to build something from scratch. https://github.com/RolifyCommunity/rolify

That's interesting. I wonder if there's special stuff in Turbolinks for that because they know the title of the page will always change, therefore they should update the title?

It sounds like you need to verify your domain ownership. Check the note at the bottom here: https://mandrill.zendesk.co...

Maybe they both support -C? Sidekiq's docs still show the capital one. https://github.com/mperham/...

Thanks man! And please do. I'm definitely wanting to correct that on here as well, but it'll probably be a low priority for a while unfortunately. Really hope it works for you so I can do the same sort of thing here.

You would actually need to store the title and url in a data attribute somewhere. Maybe on the twitter and facebook links themselves and then your JS could look for those, then find the attribute, and then populate the meta tag. That's probably what I'd do.

That would definitely showcase it.

Well, one solution would be to write some JS that fires on turbolinks page change to update those meta tags. It isn't the most elegant, but it would work just fine I think. See any reasons why that might not work?

Whoops, sorry for not being clear there! I think there are a couple things affecting your setup.

So any of the require lines at the top are Rails asset pipeline features. They will add the file to the page, but you won't be able to access any of the code in them from other files. This is fine with normal CSS, but with LESS and SASS, you often need to reference variables in other files. That means that you must use @import for those instead, not require. Also, when you import, it's as if the code is all in the same file, so you can access variables in one file from another. That's what is probably causing your issue. You'll first want to make sure you import the variables and mixins before the other files.

On a related not, it's often bad to require_tree . because it will just go import all the files in the current directory disregarding any of the requirements of which file loads before another. I would say you should probably delete that line and it could be the source of most of your problems.

So all that said, I'd recommend changing your setup to look like this:

/*
*= Any CSS and SCSS file within this...
*
*= require twitter/bootstrap
*/

@import "a_variables";
@import "mixins";
@import "mainnav";
@import "navbar";
@import "navbar-notifications";
@import "dashboard";
@import "footer";
@import "sticky-footer";

Another useful thing is you should be able to reference the original theme's code to see which order they import these files. That will be pretty much the same order you'll want to have them imported in your code.

Good luck! I hope this helps!

Okay, so here's why I never noticed it on GoRails. The head tag does get set once and then never gets updated. The next episode you click on gets the link to change on the page, but meta tags stay the same.

Since those links are on the page, you will be fine because that's what's going to initiate the share button and it will take all the properties you set. Anytime Facebook requests the page to get OpenGraph tags, they won't be using Turbolinks so that yield will work properly as well.

Effectively it's a bug, but at the same time it doesn't affect anything (at least for me). Does it cause any issues for you that the meta tags don't get updated?

Well crap. You just made me realize that mine are broken too with the same problem!

Thanks so much for the support man! I really appreciate it. :D

Ah yes, that's right. You'll want to use that instead of params[:file] in order to pass in the UploadedFile object. That's really just like a temporary file, so as long as you pass it in, you should be fine. I think if you change this in your controller, then this should work:

    Code.import(@software, code_params[:code])

That's what I'm thinking too. Not sure I'll be able to help too much other than that, but let me know if you figure it out!

Sup Robert!

So the main thing here is just to make sure that your import code sets up the association between the software you select in the UI and the codes that are imported.

You will want to adjust your import code accordingly in order to do that, so here's what I'd suggest:

1. It looks like your view should have a select for the software_id so your controller can look up the appropriate software. Looks like you've got that in there with the f.association

2. When it hits your controller, you'll want to first lookup the software these codes should be associated with. Then you'll pass that software as an additional argument into the import code.

  def import
    @software = Software.find(params[:software_id])
    Code.import(@software, params[:file])
    redirect_to codes_path, notice: 'Codes were successfully uploaded!'
  end

1. Your import method just needs to accept a new attribute and then reference the association when creating codes now:

  def self.import(software, file)
    CSV.foreach(file.path, headers: true) do |row|
      software.codes.create! row.to_hash
    end
  end

That should do the trick!

Hey Benny,

You can redirect after sign up the a ProfilesController new action. If you want to enforce it, you can set a before_action :require_profile! that redirects users to that until they have created one. All sorta depends on how you want to the user experience to be like. Just make sure your require_profile before_action gets skipped on the new and create methods for the ProfilesController and that should do the trick!