Exemplo n.º 1
0
        public async Task <IActionResult> CreateReport([FromBody] CreateReportRequest reportRequest)
        {
            await using var repository = new ApplicationContext();

            var reportRequestCar = reportRequest.Car;
            var car = repository.Cars.FirstOrDefault(x => x.CountryCode == reportRequestCar.CountryCode &&
                                                     x.Number == reportRequestCar.Number &&
                                                     x.RegionCode == reportRequestCar.RegionCode);

            if (car == null)
            {
                repository.Cars.Add(reportRequestCar);
                await repository.SaveChangesAsync();
            }
            else
            {
                reportRequestCar.Id = car.Id;
            }

            var newReport = new Report
            {
                CarId       = reportRequestCar.Id,
                Description = reportRequest.Description,
                UserId      = reportRequest.UserId,
                ImageUrl1   = reportRequest.ImageUrl1,
                ImageUrl2   = reportRequest.ImageUrl2,
                ImageUrl3   = reportRequest.ImageUrl3
            };

            repository.Reports.Add(newReport);

            return(await repository.SaveChangesAsync() > 0
                ? Ok()
                : ValidationProblem());
        }
Exemplo n.º 2
0
        public async Task <IActionResult> CreateReport([FromForm] CreateReportRequest request)
        {
            var response = await mediator.Send(request);

            logger.LogResponse(
                $"User #{HttpContext.GetCurrentUserId()} created report #{response?.Report?.Id} with subject: " +
                $"{response?.Report?.Subject.ToUpper()}", response.Error);

            return(this.CreateResponse(response));
        }
        public async Task <IActionResult> Post(ReportModel model)
        {
            var useCaseRequest = new CreateReportRequest
            {
                Model = model
            };

            var response = await _createReportUseCase.Execute(useCaseRequest);

            return(response.Data.Match <IActionResult>(item => Ok(item), item => BadRequest(item)));
        }
        //Create
        public async Task <ReportResponse> CreateReport(CreateReportRequest model)
        {
            var report = _mapper.Map <Report>(model);

            if (report == null)
            {
                throw new AppException("Create Report failed");
            }

            await _context.Reports.AddAsync(report);

            await _context.SaveChangesAsync();

            return(_mapper.Map <ReportResponse>(report));
        }
        public CreateReportRequest Build()
        {
            var user = new User
            {
                Name = _userName,
                Id   = _userId
            };

            var request = new CreateReportRequest(
                user,
                _employerId,
                _period);

            return(request);
        }
        public void And_Employer_Id_And_Period_Is_Supplied_Then_Create_Report()
        {
            //Arrange
            CreateReportRequest actualRequest = null;

            _mediatorMock.Setup(s => s.Send(It.IsAny <CreateReportRequest>(), It.IsAny <CancellationToken>()))
            .Callback <IRequest <Report>, CancellationToken>((r, c) => actualRequest = (CreateReportRequest)r)
            .ReturnsAsync(new Report {
                Id = Guid.NewGuid()
            })
            .Verifiable();

            //Act
            _reportService.CreateReport("ABCDE", _user);

            //Assert
            _mediatorMock.VerifyAll();
            Assert.AreEqual("ABCDE", actualRequest.EmployerId);
            Assert.AreEqual(_period.PeriodString, actualRequest.Period);
            Assert.AreEqual(_user.DisplayName, actualRequest.User.Name);
            Assert.AreEqual(_user.Id, actualRequest.User.Id);
        }
        public void CreateReport(string employerId, UserModel user)
        {
            var currentPeriod = _periodService.GetCurrentPeriod();

            var requestUser = new User
            {
                Name = user.DisplayName,
                Id   = user.Id
            };

            var request = new CreateReportRequest(
                requestUser,
                employerId,
                currentPeriod.PeriodString);

            var report = _mediator.Send(request).Result;


            if (report?.Id == null)
            {
                throw new Exception("Unable to create a new report");
            }
        }
        public async Task <IActionResult> CreateReport([FromBody] CreateReportRequest requestDto)
        {
            //简单过滤SqlStr  格式必须是  select @ColumnStr from table
            if (!IsRightPreviewSql(requestDto.Sqlstr))
            {
                return(Failed(ErrorCode.DataBaseError, "SQL格式有误,请检查!"));
            }
            var result          = false;
            var commonReportBiz = new CommonReportThemeBiz();
            //新申请
            var themeModel = new ReportThemeModel()
            {
                ThemeGuid       = Guid.NewGuid().ToString("N"),
                ApplyUserName   = requestDto.ApplyUserName,
                Name            = requestDto.ReportName,
                Demand          = requestDto.Demand,
                SQLStr          = requestDto.Sqlstr,
                RecordStatus    = requestDto.RecordStatus,
                Sort            = requestDto.Sort,
                CreatedBy       = UserID,
                CreationDate    = DateTime.Now,
                LastUpdatedBy   = UserID,
                LastUpdatedDate = DateTime.Now,
                PlatformType    = string.IsNullOrWhiteSpace(requestDto.PlatformType) ? "CloudDoctor" : requestDto.PlatformType,
                OrgGuid         = string.Empty,
                Enable          = true
            };
            var conditionAndColumnList = new List <ReportConditionModel>();

            foreach (var item in requestDto.CreateConditionInfoList)
            {
                var conditionModel = new ReportConditionModel()
                {
                    ConditionGuid   = Guid.NewGuid().ToString("N"),
                    ThemeGuid       = themeModel.ThemeGuid,
                    Name            = item.ConditionName,
                    FieldCode       = item.FieldCode,
                    FieldValueSql   = string.Empty,
                    IsRightSql      = true,
                    ValueType       = item.ValueType,
                    ValueRange      = string.IsNullOrWhiteSpace(item.ValueRange) ? "{}" : item.ValueRange,
                    ExtensionField  = string.Empty,
                    CreatedBy       = UserID,
                    CreationDate    = DateTime.Now,
                    LastUpdatedBy   = UserID,
                    LastUpdatedDate = DateTime.Now,
                    RecordType      = RecordTypeEnum.Condition.ToString(),
                    Required        = item.Required,
                    Sort            = item.Sort,
                    OrgGuid         = string.Empty,
                    Enable          = true
                };
                conditionAndColumnList.Add(conditionModel);
            }
            foreach (var item in requestDto.CreateColumnInfoList)
            {
                var conditionModel = new ReportConditionModel()
                {
                    ConditionGuid   = Guid.NewGuid().ToString("N"),
                    ThemeGuid       = themeModel.ThemeGuid,
                    Name            = item.ColumnName,
                    FieldCode       = item.FieldCode,
                    FieldValueSql   = string.Empty,
                    IsRightSql      = true,
                    ValueType       = item.ValueType,
                    ValueRange      = string.IsNullOrWhiteSpace(item.ValueRange) ? "{}" : item.ValueRange,
                    ExtensionField  = string.Empty,
                    CreatedBy       = UserID,
                    CreationDate    = DateTime.Now,
                    LastUpdatedBy   = UserID,
                    LastUpdatedDate = DateTime.Now,
                    RecordType      = RecordTypeEnum.Column.ToString(),
                    Required        = item.Required,
                    Sort            = item.Sort,
                    OrgGuid         = string.Empty,
                    Enable          = true
                };
                conditionAndColumnList.Add(conditionModel);
            }
            result = await commonReportBiz.ApplyCreateReport(themeModel, conditionAndColumnList);

            return(Success(result));
        }
 public async Task <ReportResponse> Create(CreateReportRequest model)
 {
     return(await _reportService.CreateReport(model));
 }