1 public class Task : Entity<long>
 2 {
 3     [ForeignKey("AssignedPersonId")]
 4     public virtual Person AssignedPerson { get; set; }
 5 
 6     public virtual int? AssignedPersonId { get; set; }
 7 
 8     public virtual string Description { get; set; }
 9 
10     public virtual DateTime CreationTime { get; set; }
11 
12     public virtual TaskState State { get; set; }
13 
14     public Task()
15     {
16         CreationTime = DateTime.Now;
17         State = TaskState.Active;
18     }
19 }

1 public class Person : Entity
2 {
3     public virtual string Name { get; set; }
4 }

 1 public class SimpleTaskSystemDbContext : AbpDbContext
 2 {
 3     public virtual IDbSet<Task> Tasks { get; set; }
 4 
 5     public virtual IDbSet<Person> People { get; set; }
 6 
 7     public SimpleTaskSystemDbContext()
 8         : base("Default")
 9     {
10 
11     }
12 
13     public SimpleTaskSystemDbContext(string nameOrConnectionString)
14         : base(nameOrConnectionString)
15     {
16             
17     }
18 }

1 <add name="Default" connectionString="Server=localhost; Database=SimpleTaskSystem; Trusted_Connection=True;" providerName="System.Data.SqlClient" />

 1 internalinternal sealed class Configuration : DbMigrationsConfiguration<SimpleTaskSystem.EntityFramework.SimpleTaskSystemDbContext>
 2 {
 3     public Configuration()
 4     {
 5         AutomaticMigrationsEnabled = false;
 6     }
 7 
 8     protected override void Seed(SimpleTaskSystem.EntityFramework.SimpleTaskSystemDbContext context)
 9     {
10         context.People.AddOrUpdate(
11             p => p.Name,
12             new Person {Name = "Isaac Asimov"},
13             new Person {Name = "Thomas More"},
14             new Person {Name = "George Orwell"},
15             new Person {Name = "Douglas Adams"}
16             );
17     }
18 }

 1 public partial class InitialCreate : DbMigration
 2 {
 3     public override void Up()
 4     {
 5         CreateTable(
 6             "dbo.StsPeople",
 7             c => new
 8                 {
 9                     Id = c.Int(nullable: false, identity: true),
10                     Name = c.String(),
11                 })
12             .PrimaryKey(t => t.Id);
13             
14         CreateTable(
15             "dbo.StsTasks",
16             c => new
17                 {
18                     Id = c.Long(nullable: false, identity: true),
19                     AssignedPersonId = c.Int(),
20                     Description = c.String(),
21                     CreationTime = c.DateTime(nullable: false),
22                     State = c.Byte(nullable: false),
23                 })
24             .PrimaryKey(t => t.Id)
25             .ForeignKey("dbo.StsPeople", t => t.AssignedPersonId)
26             .Index(t => t.AssignedPersonId);            
27     }
28         
29     public override void Down()
30     {
31         DropForeignKey("dbo.StsTasks", "AssignedPersonId", "dbo.StsPeople");
32         DropIndex("dbo.StsTasks", new[] { "AssignedPersonId" });
33         DropTable("dbo.StsTasks");
34         DropTable("dbo.StsPeople");
35     }
36 }

1 PM> Update-Database

1 public interface ITaskRepository : IRepository<Task, long>
2 {
3     List<Task> GetAllWithPeople(int? assignedPersonId, TaskState? state);
4 }

 1 public class TaskRepository : SimpleTaskSystemRepositoryBase<Task, long>, ITaskRepository
 2 {
 3     public List<Task> GetAllWithPeople(int? assignedPersonId, TaskState? state)
 4     {
 5         //In repository methods, we do not deal with create/dispose DB connections, DbContexes and transactions. ABP handles it.
 6             
 7         var query = GetAll(); //GetAll() returns IQueryable<T>, so we can query over it.
 8         //var query = Context.Tasks.AsQueryable(); //Alternatively, we can directly use EF‘s DbContext object.
 9         //var query = Table.AsQueryable(); //Another alternative: We can directly use ‘Table‘ property instead of ‘Context.Tasks‘, they are identical.
10             
11         //Add some Where conditions...
12 
13         if (assignedPersonId.HasValue)
14         {
15             query = query.Where(task => task.AssignedPerson.Id == assignedPersonId.Value);
16         }
17 
18         if (state.HasValue)
19         {
20             query = query.Where(task => task.State == state);
21         }
22 
23         return query
24             .OrderByDescending(task => task.CreationTime)
25             .Include(task => task.AssignedPerson) //Include assigned person in a single query
26             .ToList();
27     }
28 }

1 public interface ITaskAppService : IApplicationService
2 {
3     GetTasksOutput GetTasks(GetTasksInput input);
4     void UpdateTask(UpdateTaskInput input);
5     void CreateTask(CreateTaskInput input);
6 }

 1 public class TaskAppService : ApplicationService, ITaskAppService
 2 {
 3     //These members set in constructor using constructor injection.
 4         
 5     private readonly ITaskRepository _taskRepository;
 6     private readonly IRepository<Person> _personRepository;
 7         
 8     /// <summary>
 9     ///In constructor, we can get needed classes/interfaces.
10     ///They are sent here by dependency injection system automatically.
11     /// </summary>
12     public TaskAppService(ITaskRepository taskRepository, IRepository<Person> personRepository)
13     {
14         _taskRepository = taskRepository;
15         _personRepository = personRepository;
16     }
17         
18     public GetTasksOutput GetTasks(GetTasksInput input)
19     {
20         //Called specific GetAllWithPeople method of task repository.
21         var tasks = _taskRepository.GetAllWithPeople(input.AssignedPersonId, input.State);
22 
23         //Used AutoMapper to automatically convert List<Task> to List<TaskDto>.
24         return new GetTasksOutput
25                 {
26                     Tasks = Mapper.Map<List<TaskDto>>(tasks)
27                 };
28     }
29         
30     public void UpdateTask(UpdateTaskInput input)
31     {
32         //We can use Logger, it‘s defined in ApplicationService base class.
33         Logger.Info("Updating a task for input: " + input);
34 
35         //Retrieving a task entity with given id using standard Get method of repositories.
36         var task = _taskRepository.Get(input.TaskId);
37 
38         //Updating changed properties of the retrieved task entity.
39 
40         if (input.State.HasValue)
41         {
42             task.State = input.State.Value;
43         }
44 
45         if (input.AssignedPersonId.HasValue)
46         {
47             task.AssignedPerson = _personRepository.Load(input.AssignedPersonId.Value);
48         }
49 
50         //We even do not call Update method of the repository.
51         //Because an application service method is a ‘unit of work‘ scope as default.
52         //ABP automatically saves all changes when a ‘unit of work‘ scope ends (without any exception).
53     }
54 
55     public void CreateTask(CreateTaskInput input)
56     {
57         //We can use Logger, it‘s defined in ApplicationService class.
58         Logger.Info("Creating a task for input: " + input);
59 
60         //Creating a new Task entity with given input‘s properties
61         var task = new Task { Description = input.Description };
62 
63         if (input.AssignedPersonId.HasValue)
64         {
65             task.AssignedPersonId = input.AssignedPersonId.Value;
66         }
67 
68         //Saving entity with standard Insert method of repositories.
69         _taskRepository.Insert(task);
70     }
71 }

1 public class CreateTaskInput
2 {
3     public int? AssignedPersonId { get; set; }
4 
5     [Required]
6     public string Description { get; set; }
7 }

 1 public class UpdateTaskInput : ICustomValidate
 2 {
 3     [Range(1, long.MaxValue)]
 4     public long TaskId { get; set; }
 5 
 6     public int? AssignedPersonId { get; set; }
 7 
 8     public TaskState? State { get; set; }
 9 
10     public void AddValidationErrors(List<ValidationResult> results)
11     {
12         if (AssignedPersonId == null && State == null)
13         {
14             results.Add(new ValidationResult("Both of AssignedPersonId and State can not be null in order to update a Task!", new[] { "AssignedPersonId", "State" }));
15         }
16     }
17 
18     public override string ToString()
19     {
20         return string.Format("[UpdateTask > TaskId = {0}, AssignedPersonId = {1}, State = {2}]", TaskId, AssignedPersonId, State);
21     }
22 }

1 DynamicApiControllerBuilder
2     .ForAll<IApplicationService>(Assembly.GetAssembly(typeof (SimpleTaskSystemApplicationModule)), "tasksystem")
3     .Build();

 1 app.config([
 2     ‘$stateProvider‘, ‘$urlRouterProvider‘,
 3     function ($stateProvider, $urlRouterProvider) {
 4         $urlRouterProvider.otherwise(‘/‘);
 5         $stateProvider
 6             .state(‘tasklist‘, {
 7                 url: ‘/‘,
 8                 templateUrl: ‘/App/Main/views/task/list.cshtml‘,
 9                 menu: ‘TaskList‘ //Matches to name of ‘TaskList‘ menu in SimpleTaskSystemNavigationProvider
10             })
11             .state(‘newtask‘, {
12                 url: ‘/new‘,
13                 templateUrl: ‘/App/Main/views/task/new.cshtml‘,
14                 menu: ‘NewTask‘ //Matches to name of ‘NewTask‘ menu in SimpleTaskSystemNavigationProvider
15             });
16     }
17 ]);

 1 (function() {
 2     var app = angular.module(‘app‘);
 3 
 4     var controllerId = ‘sts.views.task.list‘;
 5     app.controller(controllerId, [
 6         ‘$scope‘, ‘abp.services.tasksystem.task‘,
 7         function($scope, taskService) {
 8             var vm = this;
 9 
10             vm.localize = abp.localization.getSource(‘SimpleTaskSystem‘);
11 
12             vm.tasks = [];
13 
14             $scope.selectedTaskState = 0;
15 
16             $scope.$watch(‘selectedTaskState‘, function(value) {
17                 vm.refreshTasks();
18             });
19 
20             vm.refreshTasks = function() {
21                 abp.ui.setBusy( //Set whole page busy until getTasks complete
22                     null,
23                     taskService.getTasks({ //Call application service method directly from javascript
24                         state: $scope.selectedTaskState > 0 ? $scope.selectedTaskState : null
25                     }).success(function(data) {
26                         vm.tasks = data.tasks;
27                     })
28                 );
29             };
30 
31             vm.changeTaskState = function(task) {
32                 var newState;
33                 if (task.state == 1) {
34                     newState = 2; //Completed
35                 } else {
36                     newState = 1; //Active
37                 }
38 
39                 taskService.updateTask({
40                     taskId: task.id,
41                     state: newState
42                 }).success(function() {
43                     task.state = newState;
44                     abp.notify.info(vm.localize(‘TaskUpdatedMessage‘));
45                 });
46             };
47 
48             vm.getTaskCountText = function() {
49                 return abp.utils.formatString(vm.localize(‘Xtasks‘), vm.tasks.length);
50             };
51         }
52     ]);
53 })();

 1 <div class="panel panel-default" ng-controller="sts.views.task.list as vm">
 2 
 3     <div class="panel-heading" style="position: relative;">
 4         <div class="row">
 5             
 6             <!-- Title -->
 7             <h3 class="panel-title col-xs-6">
 8                 @L("TaskList") - <span>{{vm.getTaskCountText()}}</span>
 9             </h3>
10             
11             <!-- Task state combobox -->
12             <div class="col-xs-6 text-right">
13                 <select ng-model="selectedTaskState">
14                     <option value="0">@L("AllTasks")</option>
15                     <option value="1">@L("ActiveTasks")</option>
16                     <option value="2">@L("CompletedTasks")</option>
17                 </select>
18             </div>
19         </div>
20     </div>
21 
22     <!-- Task list -->
23     <ul class="list-group" ng-repeat="task in vm.tasks">
24         <div class="list-group-item">
25             <span class="task-state-icon glyphicon" ng-click="vm.changeTaskState(task)" ng-class="{‘glyphicon-minus‘: task.state == 1, ‘glyphicon-ok‘: task.state == 2}"></span>
26             <span ng-class="{‘task-description-active‘: task.state == 1, ‘task-description-completed‘: task.state == 2 }">{{task.description}}</span>
27             <br />
28             <span ng-show="task.assignedPersonId > 0">
29                 <span class="task-assignedto">{{task.assignedPersonName}}</span>
30             </span>
31             <span class="task-creationtime">{{task.creationTime}}</span>
32         </div>
33     </ul>
34 
35 </div>

 1 <?xml version="1.0" encoding="utf-8" ?>
 2 <localizationDictionary culture="en">
 3   <texts>
 4     <text name="TaskSystem" value="Task System" />
 5     <text name="TaskList" value="Task List" />
 6     <text name="NewTask" value="New Task" />
 7     <text name="Xtasks" value="{0} tasks" />
 8     <text name="AllTasks" value="All tasks" />
 9     <text name="ActiveTasks" value="Active tasks" />
10     <text name="CompletedTasks" value="Completed tasks" />
11     <text name="TaskDescription" value="Task description" />
12     <text name="EnterDescriptionHere" value="Task description" />
13     <text name="AssignTo" value="Assign to" />
14     <text name="SelectPerson" value="Select person" />
15     <text name="CreateTheTask" value="Create the task" />
16     <text name="TaskUpdatedMessage" value="Task has been successfully updated." />
17     <text name="TaskCreatedMessage" value="Task {0} has been created successfully." />
18   </texts>
19 </localizationDictionary>