6

Background

I have an Asp.net MVC 3.5 application that imports Products using a CSV file. CSV files can come from a specific group of configurable sources. To configure a new CSV source the user would initially specify which CSV columns map to which Product properties. This configuration will be stored as an import template and made available for selection thereafter when each import is performed.

I've run into a wall in attempting to plan the folder/object structure for this feature. I understand (and love) the flexibility of Asp.net MVC for routing so I know we could do just about anything here. However, I'd like any advice that would help us keep the object structure more sound and maintainable.

Initially I setup a Product folder containing an Import.aspx View. This seems to fit the controller/action model well enough. However, when I consider the features for managing the templates mentioned above, things get confusing.

EDIT: An Import Template can be applied to different objects. So Product is just one object that could have one or more ImportTemplates created for it. For example, another object that may have an ImportTemplate could be Customer.

Question

Should I create under the Product folder a subfolder called ImportTemplate and place the CRUD Views there? I would then add a custom route for Import Template functions. My concern here is the folder depth as well as the confusion with the sibling action Import. Or should the ImportTemplate be up a level and then use routing to place it under the Product folder? Sounds messy.

Maybe the folder structure should be Product/Import/Template. The problem I see in this case is that the Import is not really an object. I can see it being a controller but it is really meant to be the action. If I use this structure, should I place an Upload.aspx View in the Import folder (to replace the Product/Import.aspx mentioned above)? This seems to get a little clunky.

EDIT: With the added requirement above that an ImportTemplate can be associated with objects other than Product (i.e. Customer) would it be better to have the ImportTemplate folder directly under the Views folder?

Any alternative ideas for structuring this object/folder hierarchy?

Research

In an attempt to research this issue I reviewed questions about folder structure and depth. Here are several questions that had answers but really did not provide an answer to my question.

-ASP.NET MVC How many levels deep should a view or URL be?

-ASP.NET MVC 3 folder structures

-Strategy for Hierarchical MVC Routing

An Example

EDIT: A user regularly imports a list of products from a 3rd party. They are importing data from a CSV file that will be uploaded to the web site. They create/add an instance of a Product Import Template to their account. This template instance stores the following settings:

  • The column named "title" in the CSV file should be imported to the Product Name field.
  • Unrecognized categories under the "category" column in the CSV should be imported as "Unknown" category.

A different user may have different rules based on a different 3rd party CSV format or based on their own system configuration (i.e. they don't have an Unknown category setup as the user above).

  • The column named "part number" in the CSV should be imported to the Product Name field and the Product Number field.
  • Unrecognized categories should import by default into the "Generic" category.
Improve this question
2
  • Are your templates saved as views or are they merely functions/saved mappings for columns? Commented Feb 19, 2013 at 22:20
  • @Jack they are currently planned to be saved mappings for columns. Commented Feb 20, 2013 at 10:07

1 Answer 1

Reset to default
0

You’re absolutely correct that given the flexibility of ASP MVC you can do just about anything here in regards to folder structure. If you’re used to ASP.NET WebForms, remember that MVC is completely different in that it doesn't use folders and files as direct mapping for resources, and routes are based on controllers and actions. This can take getting used to when you're used to doing it the "ASP classic" way.

So, the key consideration is what makes the most sense to you and your users, and that everyone is clear where everything is.

Maybe the folder structure should be Product/Import/Template. The problem I see in this case is that the Import is not really an object. I can see it being a controller but it is really meant to be the action. If I use this structure, should I place an Upload.aspx View in the Import folder (to replace the Product/Import.aspx mentioned above)? This seems to get a little clunky.

Yes, it sounds like your controllers should have an Import action, or Upload action, etc… Each of these could have a corresponding view in that controller’s view folder, but the templates themselves probably don’t need to be views. Your templates are merely a resource that will be referenced by a controller action when importing products. In this case, custom routing won’t be an issue and I wouldn't place the templates in view folders. I’d put them in a central location and reference them in all of my controllers that need to access them for an import action.

You can use something like this:

MyApp project
    Controllers
        ProductController
    Models
        Product
    ImportTemplate
        Template1
        Template2
    Views
        Product
            Import.aspx
            Edit.aspx
            Index.aspx
            etc…

The Import.aspx, or Upload.aspx might be pages where the user can select a template and import products (or map columns and save a new template). Each view will have a corresponding controller action. Your controller’s import or upload action will access the template files directly; all you’ll need to do is include a reference to ImportTemplate folder in your controller (or Model, Service Layer… anywhere that the template will be used) 

using  MyApp.ImportTemplate
//namespace matches folder structure, “MyApp/ImportTemplate”

When the user is on the product import page the URL will resemble /Product/Import/ and the template itself doesn’t necessarily appear in the URL unless you pass it as a parameter /Product/Import/templateID or /Product/Import?templateID=123456.

Again, the key is to do what makes the best sense for your projects and keeps things organized and clear for you, and in a way that can save you time when you’re building/deploying your application.

For example, I tend to split things up into two or more projects to make it easier for me when it comes time to deploy. As an example, I might have a folder structure like this:

App.UI project
    Content
        CSS
    Scripts
    Images
    Views

App.Core project (any code that will be compiled)
    Controllers
    Templates
    Models
        Helpers
        Interfaces
        Repositories
    ViewModels

Then all I need to deploy is the App.UI project, and everything in App.Core will be compiled and included in the App.UI\bin folder

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

the number of templates will vary per user based on the vendors from whom they are choosing to import. Since there is a possibility of new vendors and since the way they will integrate for each user could also vary, the UI will need some dynamic means of adding, editing and removing templates. Wouldn't adding and editing template "instances" be a good candidate for one or more views? I know I could make dynamic classes work in a Core library but in this case the functionality will be the same for every template. Only the field mapping will change per instance.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.