public void Validate_DtoNameAlreadyExists_ReturnsCorrectErrorMessage()
        {
            var name = "Barbell";
            var user = new User {
                Id = NextId
            };

            Context.Users.Add(user);

            var equipment = new Equipment {
                UserId = user.Id, Name = name
            };

            Context.Equipments.Add(equipment);
            Context.SaveChanges();

            var request = new EquipmentCreateDto {
                UserId = user.Id, Name = name
            };
            var validator = new EquipmentCreateDtoValidator(Context);
            var result    = validator.Validate(request);

            var hasCorrectErrorMessage = result.Errors.Any(x =>
                                                           x.ErrorMessage == $"You already have the equipment '{request.Name}'" &&
                                                           x.PropertyName == nameof(EquipmentCreateDto.Name));

            Assert.IsTrue(hasCorrectErrorMessage);
        }
        public IActionResult Create([FromBody] EquipmentCreateDto parm)
        {
            try
            {
                var line = parm.Adapt <Base_Equipment>().ToCreate(_tokenManager.GetSessionInfo());

                if (_equipmentService.Any(m => m.EquipNo == parm.EquipNo))
                {
                    return(toResponse(StatusCodeType.Error, $"添加机台编码 {parm.EquipNo} 已存在,不能重复!"));
                }

                //从 Dto 映射到 实体
                _unitOfWork.BeginTran();

                var response = _equipmentService.Add(line);

                //插入关系表
                _dataRelationService.Add(new Sys_DataRelation
                {
                    ID   = GetGUID,
                    Form = line.ID,
                    To   = parm.LineUID,
                    Type = DataRelationType.Equipment_To_Line.ToString()
                });

                _unitOfWork.CommitTran();

                return(toResponse(response));
            }
            catch (Exception)
            {
                _unitOfWork.RollbackTran();
                throw;
            }
        }
        public void CreateEquipment_NameHasValue_ReturnsNameThatWasGiven()
        {
            var name    = $"{NextId}";
            var request = new EquipmentCreateDto {
                Name = name
            };

            var repo   = new EquipmentRepository(Context);
            var result = repo.CreateEquipment(request);

            Assert.AreEqual(name, result.Name);
        }
        public void CreateEquipment_NameHasValue_ContextHasNewEquipmentWithCorrectName()
        {
            var name    = $"{NextId}";
            var request = new EquipmentCreateDto {
                Name = name
            };

            var repo   = new EquipmentRepository(Context);
            var result = repo.CreateEquipment(request);
            var equipmentFromContext = Context.Equipments.Find(result.Id);

            Assert.AreEqual(name, equipmentFromContext.Name);
        }
        public void Validate_EquipmentNameIsEmpty_ReturnsCorrectErrorMessage()
        {
            var request = new EquipmentCreateDto();

            var validator = new EquipmentCreateDtoValidator(Context);
            var result    = validator.Validate(request);

            var hasCorrectErrorMessage = result.Errors.Any(x =>
                                                           x.ErrorMessage == "'Name' must not be empty." &&
                                                           x.PropertyName == nameof(EquipmentCreateDto.Name));

            Assert.IsTrue(hasCorrectErrorMessage);
        }
        public void CreateEquipment_UserIdHasValue_ReturnsUserIdThatWasGiven()
        {
            // Arrange
            var UserId  = NextId;
            var request = new EquipmentCreateDto {
                UserId = UserId
            };

            // Act
            var repo   = new EquipmentRepository(Context);
            var result = repo.CreateEquipment(request);

            // Assert
            Assert.AreEqual(UserId, result.UserId);
        }
        public void Validate_UserIdDoesNotExist_ReturnsCorrectErrorMessage()
        {
            var request = new EquipmentCreateDto {
                UserId = NextId
            };

            var validator = new EquipmentCreateDtoValidator(Context);
            var result    = validator.Validate(request);

            var hasCorrectErrorMessage = result.Errors.Any(x =>
                                                           x.ErrorMessage == "The 'User' does not exist." &&
                                                           x.PropertyName == nameof(EquipmentCreateDto.UserId));

            Assert.IsTrue(hasCorrectErrorMessage);
        }
        public void CreateEquipment_UserIdHasValue_ContextHasNewRoutineWithCorrectUserId()
        {
            // Arrange
            var UserId  = NextId;
            var request = new EquipmentCreateDto {
                UserId = UserId
            };

            // Act
            var repo               = new EquipmentRepository(Context);
            var result             = repo.CreateEquipment(request);
            var routineFromContext = Context.Equipments.Find(result.Id);

            // Assert
            Assert.AreEqual(UserId, routineFromContext.UserId);
        }
        public void Validate_EverythingWorks_ReturnsNoErrorMessage()
        {
            var name    = "Barbell";
            var request = new EquipmentCreateDto {
                UserId = NextId, Name = name
            };

            var validator = new EquipmentCreateDtoValidator(Context);
            var result    = validator.Validate(request);

            var hasCorrectErrorMessage = result.Errors.Any(x =>
                                                           x.ErrorMessage == "The 'User' does not exist." &&
                                                           x.PropertyName == "");

            Assert.IsTrue(!hasCorrectErrorMessage);
        }
Example #10
0
        public IActionResult Post([FromBody] EquipmentCreateDto equipmentCreateDto)
        {
            var userIdString = User.FindFirst(ClaimTypes.Name)?.Value;
            var userId       = int.Parse(userIdString);

            equipmentCreateDto.UserId = userId;

            var validationResult = _equipmentCreateDtoValidator.Validate(equipmentCreateDto);

            if (!validationResult.IsValid)
            {
                return(BadRequest(ValidationHelpers.ConvertValidationResult(validationResult)));
            }

            var equipment = _equipmentRepository.CreateEquipment(equipmentCreateDto);

            return(Created("[controller]", equipment));
        }
Example #11
0
        public EquipmentGetDto CreateEquipment(EquipmentCreateDto equipmentCreateDto)
        {
            var equipment = new Equipment
            {
                Name   = equipmentCreateDto.Name,
                UserId = equipmentCreateDto.UserId
            };

            _context.Set <Equipment>().Add(equipment);
            _context.SaveChanges();

            var equipmentGetDto = new EquipmentGetDto
            {
                Id     = equipment.Id,
                Name   = equipment.Name,
                UserId = equipment.UserId
            };

            return(equipmentGetDto);
        }