public ResponsibilityReasonDto Map(ResponsibilityReason entity)
 {
     return new ResponsibilityReasonDto()
     {
         Id = entity.Id,
         Reason = entity.Reason
     };
 }
        public void Setup()
        {
            _createdBy = new UserForAuditing() { Id = Guid.NewGuid() };
            _createdOn = DateTime.Now;
            _deleted = false;
            _initialTaskReoccurringType = TaskReoccurringType.FiveYearly;
            _lastModifiedBy = new UserForAuditing() { Id = Guid.NewGuid() };
            _lastModifiedOn = DateTime.Now;
            _owner = new Employee() { Id = Guid.NewGuid() };
            _site = new Site() { Id = 1346624L };
            _responsibilityCategory = new ResponsibilityCategory() { Id = 21345642L };
            _responsibilityReason = new ResponsibilityReason() { Id = 1234523L };

            _statutoryResponsibilityTaskTemplate = new StatutoryResponsibilityTaskTemplate
                                                       {
                                                           Id = 1L
                                                       };


            _responsibilityTasks = new List<ResponsibilityTask>
                                       {
                                           new ResponsibilityTask
                                               {
                                                   Id = 1L,
                                                   Category = TaskCategory.Create(1, "Test"),
                                                   StatutoryResponsibilityTaskTemplateCreatedFrom =
                                                       _statutoryResponsibilityTaskTemplate
                                               }
                                       };

            _entity = new Mock<Responsibility>();

            _entity.Setup(x => x.Id).Returns(_id);
            _entity.Setup(x => x.CompanyId).Returns(_companyId);
            _entity.Setup(x => x.Description).Returns(_description);
            _entity.Setup(x => x.Site).Returns(_site);
            _entity.Setup(x => x.InitialTaskReoccurringType).Returns(_initialTaskReoccurringType);
            _entity.Setup(x => x.Owner).Returns(_owner);
            _entity.Setup(x => x.Title).Returns(_title);
            _entity.Setup(x => x.ResponsibilityCategory).Returns(_responsibilityCategory);
            _entity.Setup(x => x.ResponsibilityReason).Returns(_responsibilityReason);
            _entity.Setup(x => x.CreatedOn).Returns(_createdOn);
            _entity.Setup(x => x.GetStatusDerivedFromTasks()).Returns(_status);
            _entity.Setup(x => x.Deleted).Returns(_deleted);
            _entity.Setup(x => x.CreatedBy).Returns(_createdBy);
            _entity.Setup(x => x.LastModifiedBy).Returns(_lastModifiedBy);
            _entity.Setup(x => x.LastModifiedOn).Returns(_lastModifiedOn);
            _entity.Setup(x => x.ResponsibilityTasks).Returns(_responsibilityTasks);
        }
Ejemplo n.º 3
0
        public void When_Create_Then_Return_Responsibility()
        {
            // Given
            var category = new ResponsibilityCategory();
            const string title = "R1";
            const string description = "R Test";
            var site = new Site();
            var reason = new ResponsibilityReason();
            var owner = new Employee ();
            const TaskReoccurringType frequency = TaskReoccurringType.Weekly;
            var user = new UserForAuditing();
            var template = new StatutoryResponsibilityTemplate();
        
            // When
            var result = Responsibility.Create(default(long),
                category,
                title,
                description,
                site,
                reason,
                owner,
                frequency, template,
                user
                );

            // Then

            Assert.AreEqual(category,result.ResponsibilityCategory);
            Assert.AreEqual(title,result.Title);
            Assert.AreEqual(description,result.Description);
            Assert.AreEqual(site,result.Site);
            Assert.AreEqual(reason,result.ResponsibilityReason);
            Assert.AreEqual(owner,result.Owner);
            Assert.AreEqual(frequency,result.InitialTaskReoccurringType);
            Assert.AreEqual(user,result.CreatedBy);
            Assert.AreEqual(template, result.StatutoryResponsibilityTemplateCreatedFrom);
            Assert.That(result, Is.InstanceOf<Responsibility>());
        }
        private Responsibility GetResponsibility(SaveResponsibilityRequest request, ResponsibilityReason reason, Employee owner, UserForAuditing user, Site site, ResponsibilityCategory category)
        {
            Responsibility responsibility;

            if (request.ResponsibilityId != default(long))
            {
                responsibility = _responsibilityRepository.GetById(request.ResponsibilityId);

                responsibility.Update(
                    request.CompanyId,
                    category,
                    request.Title,
                    request.Description,
                    site,
                    reason,
                    owner,
                    request.TaskReoccurringType,
                    user
                    );
            }
            else
            {
                responsibility = Responsibility.Create(
                    request.CompanyId,
                    category,
                    request.Title,
                    request.Description,
                    site,
                    reason,
                    owner,
                    request.TaskReoccurringType, null,
                    user
                    );
            }
            return responsibility;
        }