CRM

'CRM' is a comprehensive Customer Relationship Management solution that is included with the Pro edition of Dofactory .NET. As with all our products, it comes with 100% source code.

This CRM solution is similar to Salesforce, with objects like Campaigns, Leads, Opportunities, Accounts, Contacts, and more. This application is the crown-jewel of Dofactory .NET with the best design, the best code, the best patterns, and it's based on our Ultra Clean™ architecture. CRM is truly a unique and valuable resource for .NET developers and architects.

Remarkably, CRM was written in just 33 days by a single developer following the step-by-step App Factory™ guide. The 33-Day App Factory™ is included with the Pro edition of Dofactory .NET which means you can now also build applications at lightning speed.

Imagine being able to develop your next application in 33 days. Think what that will do to your career!

To view the pages click on the menu on the left under VIEW APPLICATION PAGES. Soon you'll deliver similar results in your own applications.

VIEW APPLICATION PAGES
CRM DESIGN PATTERNS

Create a comprehensive CRM solutions in just 33 days with modern patterns and RAD techniques. 100% source code.

PATTERNS & FEATURES
  • Authentication
  • Authorization
  • Modular Design
  • Excel Import
  • Excel Export
  • Data Caching
  • Lazy Injection
  • Global Error Handling
  • Intuitive UI/UX
  • Analytics/Charting
  • CRUD Actions
  • Sorting
  • Searching, Filtering
  • Pagination
  • Master-Detail
  • Gang of Four Patterns
  • Enterprise Patterns
  • Architecture Patterns
  • Design Excellence Principles
  • Code Excellence Principles

CRM is a Customer Relationship Management solution that demonstrates the type of application that you can be build in just 33 days with the App Factory™.

CRM is designed for sales and marketing professionals to keep track of their business activities. This includes leads, opportunities, accounts, contacts, tasks, campaigns, and cases.

The application is similar in functionality to Salesforce CRM, which underscores the breadth and depth of what can be accomplished in 33 days with the App Factory™.

The database has 7 main entities matching the modules listed above: Leads, Opportunities, Accounts, Contacts, etc., as well as 7 additional supporting entities. Ultra-Clean™ data models usually don't have a boatload of tables. Below is a list of the tables, which also includes the ASP.NET Identity tables.

As a general rule of thumb, the CRM reference application represents a good example of the level of functionality that can be accomplished in 33 days.

ASP.NET Identity is used for identity management, authentication, and authorization.  Two roles are supported: Admin, and User. Only Admin users have access to the Administrative pages.

As usual, 100% source code is included which you can use in your own projects. Patterns and features of this solution are listed to your left under PATTERNS AND FEATURES.

CRM is fully DX (Design Excellence™) and CX (Code Excellence™) compliant, creating a solution with minimal footprint and code that is easy to create, maintain, and extend. Note: DX and CX are application architectural guides that are part of the Dofactory .NET package.

DX (Design Excellence™) is designed to help you design modular applications with pages that flow naturally and that are easy to understand by the end-users. Below is an example of the basic page flow that you'll find in each module of this application.

CX (Code Excellence™) is designed to help you create simple, light-weight VS solutions. Below is a screenshot of the entire CRM solution.  One project and just 4 folders: Areas, Code, Data, and Domain.

The next images show the expanded folders.

Below is the Areas folder. The _Base and _Related subfolders at the top contain partial views that are shared throughout the solution.

Next is the expanded _Base folder. It contains partial views that you'll find in all our solutions. The important ones are: _Layout, _Header, _Footer, _Css, and _Js. Their names are self explanatory.

The _Layout is simple. All Dofactory .NET solutions use the same _Layout format.

Infrastructure code resides in a folder named Code.
Each category in its own subfolder.

The LocalDb database is placed in the Data folder.
When using SQL Server there will be no database here.

Reverse engineered EF entities using the Database First approach are located in the Domain folder. It's interesting to see that a feature-rich application like CRM can have just 14 entities. So simple.

The models, views, and controllers of a module (Area) are located in a single folder (see Opportunities Area below). Models and Views are paired with the same names, for example, List.cs, List.cshtml, and Detail.cs, Detail.cshtml, and others.  Files prefixed with an _ (underscore) are area-specific partial views and their models.

Below is the Opportunities controller which is low-code with just 30 lines of code (for the entire module). It supports the basic CRUD action methods: List, Detail, Edit, and Delete. Two Ancillary action methods are NextStage and Export (Excel export).

Notice, there is no dependency injection, and each action method is just a single line of code. All controllers follow this simple pattern in which controller endpoints dispatch their requests to an Actionmodel. Actionmodels handle the requests, one for each request -- a perfect implementation of the SRP principle.

An Actionmodel is a viewmodel with methods -- we know that some of you may frown upon this :-). Below is an example of the List Actionmodel which handles the Opportunity List page request. This page lists all the opportunities and includes support for sorting, filtering, pagination, search, etc. (you can see a screenshot above). All with just 119 lines of code!

In Dofactory .NET each Actionmodel has 4 regions: Data, Handlers, Helpers, and Mapping.

A Data region holds the same data you see in a Viewmodel, including filter, sort, and pagination selections posted back from the page.

A Handlers region below has a single GetAsync method that processes the request. It's very simple with just 2 database queries that support any combination of paginate, filter, and sort actions.

Continuing with the Actionmodel regions, the Helpers region has a single method that helps to build the EF Core query. Finally, the Mapping region is where AutoMapper mappings are defined for this request.

As you can see, Dofactory .NET delivers simplicity and developer productivity.

And that is it!  Wouldn't you rather create solutions like these and write your application in days rather than months or years?

Stay Inspired!
Join other developers and designers who have already signed up for our mailing list.
Terms     Privacy     Licensing       EULA       Sitemap      
© Data & Object Factory, LLC.
Made with    in Austin, Texas