Beispiel #1
0
        public async Task <University_Majors> Create(University_Majors university_Majors)
        {
            if (!await university_MajorsValidator.Create(university_Majors))
            {
                return(university_Majors);
            }

            try
            {
                university_Majors.Id = Guid.NewGuid();
                await UOW.Begin();

                await UOW.University_MajorsRepository.Create(university_Majors);

                await UOW.Commit();

                return(await Get(university_Majors.Id));
            }
            catch (Exception ex)
            {
                await UOW.Rollback();

                throw new MessageException(ex);
            }
        }
Beispiel #2
0
        public async Task <ActionResult <University_MajorsDTO> > Update([FromBody] University_MajorsDTO university_MajorsDTO)
        {
            if (university_MajorsDTO == null)
            {
                university_MajorsDTO = new University_MajorsDTO();
            }

            University_Majors university_Majors = ConvertDTOtoBO(university_MajorsDTO);

            university_Majors = await university_MajorsService.Update(university_Majors);

            university_MajorsDTO = new University_MajorsDTO
            {
                Id                = university_Majors.Id,
                MajorsId          = university_Majors.MajorsId,
                MajorsCode        = university_Majors.MajorsCode,
                MajorsName        = university_Majors.MajorsName,
                UniversityId      = university_Majors.UniversityId,
                UniversityCode    = university_Majors.UniversityCode,
                UniversityName    = university_Majors.UniversityName,
                UniversityAddress = university_Majors.UniversityAddress,
                Year              = university_Majors.Year,
                Errors            = university_Majors.Errors
            };
            if (university_Majors.HasError)
            {
                return(BadRequest(university_MajorsDTO));
            }
            return(Ok(university_MajorsDTO));
        }
        public async Task <bool> Update(University_Majors university_Majors)
        {
            bool IsValid = true;

            IsValid &= await IsExisted(university_Majors);

            return(IsValid);
        }
        public async Task <bool> Create(University_Majors university_Majors)
        {
            bool IsValid = true;

            IsValid &= await CodeValidate(university_Majors);

            return(IsValid);
        }
 private async Task <bool> IsExisted(University_Majors university_Majors)
 {
     //Kiểm tra sự tồn tại trong DB
     if (await UOW.University_MajorsRepository.Get(university_Majors.Id) == null)
     {
         university_Majors.AddError(nameof(University_MajorsValidator), nameof(university_Majors.MajorsName), ErrorCode.NotExisted);
     }
     return(university_Majors.IsValidated);
 }
Beispiel #6
0
        public async Task <University_Majors> Get(Guid Id)
        {
            if (Id == Guid.Empty)
            {
                return(null);
            }
            University_Majors University_Majors = await UOW.University_MajorsRepository.Get(Id);

            return(University_Majors);
        }
Beispiel #7
0
        public async Task <bool> Update(University_Majors university_Majors)
        {
            await tFContext.University_Majors.Where(m => m.Id == university_Majors.Id).UpdateFromQueryAsync(u => new University_MajorsDAO
            {
                UniversityId = university_Majors.UniversityId,
                MajorsId     = university_Majors.MajorsId,
            });

            return(true);
        }
Beispiel #8
0
 public University_MajorsDTO(University_Majors university_Majors)
 {
     Id             = university_Majors.Id;
     UniversityId   = university_Majors.UniversityId;
     UniversityCode = university_Majors.UniversityCode;
     UniversityName = university_Majors.UniversityName;
     MajorsId       = university_Majors.MajorsId;
     MajorsCode     = university_Majors.MajorsCode;
     MajorsName     = university_Majors.MajorsName;
     Year           = university_Majors.Year;
 }
Beispiel #9
0
        public async Task <bool> Create(University_Majors university_Majors)
        {
            University_MajorsDAO university_MajorsDAO = new University_MajorsDAO
            {
                Id           = university_Majors.Id,
                MajorsId     = university_Majors.MajorsId,
                UniversityId = university_Majors.UniversityId,
                Year         = university_Majors.Year
            };

            tFContext.University_Majors.Add(university_MajorsDAO);
            await tFContext.SaveChangesAsync();

            return(true);
        }
Beispiel #10
0
        public async Task <University_Majors> Get(long Id)
        {
            University_Majors University_Majors = await eMSContext.University_Majors.Where(m => m.Id == Id).Select(u => new University_Majors
            {
                Id             = u.Id,
                UniversityId   = u.UniversityId,
                UniversityCode = u.University.Code,
                UniversityName = u.University.Name,
                MajorsId       = u.MajorsId,
                MajorsCode     = u.Majors.Code,
                MajorsName     = u.Majors.Name,
                Year           = u.Year
            }).FirstOrDefaultAsync();

            return(University_Majors);
        }
Beispiel #11
0
        private University_Majors ConvertDTOtoBO(University_MajorsDTO university_MajorsDTO)
        {
            University_Majors University_Majors = new University_Majors
            {
                Id                = university_MajorsDTO.Id,
                MajorsId          = university_MajorsDTO.MajorsId,
                MajorsCode        = university_MajorsDTO.MajorsCode,
                MajorsName        = university_MajorsDTO.MajorsName,
                UniversityId      = university_MajorsDTO.UniversityId,
                UniversityCode    = university_MajorsDTO.UniversityCode,
                UniversityName    = university_MajorsDTO.UniversityName,
                UniversityAddress = university_MajorsDTO.UniversityAddress,
                Year              = university_MajorsDTO.Year
            };

            return(University_Majors);
        }
        private async Task <bool> CodeValidate(University_Majors university_Majors)
        {
            //Kiểm tra Code nhập vào đã tồn tại trong Db chưa
            University_MajorsFilter filter = new University_MajorsFilter
            {
                MajorsId     = university_Majors.MajorsId,
                UniversityId = university_Majors.UniversityId,
                Year         = new StringFilter {
                    Equal = university_Majors.Year
                }
            };

            var count = await UOW.University_MajorsRepository.Count(filter);

            if (count > 0)
            {
                university_Majors.AddError(nameof(University_MajorsValidator), nameof(university_Majors.MajorsName), ErrorCode.Duplicate);
            }
            return(university_Majors.IsValidated);
        }
Beispiel #13
0
        public async Task <University_MajorsDTO> Get([FromBody] University_MajorsDTO university_MajorsDTO)
        {
            if (university_MajorsDTO == null)
            {
                university_MajorsDTO = new University_MajorsDTO();
            }

            University_Majors university_Majors = ConvertDTOtoBO(university_MajorsDTO);

            university_Majors = await university_MajorsService.Get(university_Majors.Id);

            return(university_Majors == null ? null : new University_MajorsDTO()
            {
                Id = university_Majors.Id,
                MajorsId = university_Majors.MajorsId,
                MajorsCode = university_Majors.MajorsCode,
                MajorsName = university_Majors.MajorsName,
                UniversityId = university_Majors.UniversityId,
                UniversityCode = university_Majors.UniversityCode,
                UniversityName = university_Majors.UniversityName,
                UniversityAddress = university_Majors.UniversityAddress,
                Year = university_Majors.Year,
            });
        }
Beispiel #14
0
        public async Task <University_Majors> Delete(University_Majors university_Majors)
        {
            if (!await university_MajorsValidator.Delete(university_Majors))
            {
                return(university_Majors);
            }

            try
            {
                await UOW.Begin();

                await UOW.University_MajorsRepository.Delete(university_Majors.Id);

                await UOW.Commit();

                return(university_Majors);
            }
            catch (Exception ex)
            {
                await UOW.Rollback();

                throw new MessageException(ex);
            }
        }
Beispiel #15
0
        public async Task <ActionResult <University_Majors_SubjectGroupDTO> > Create([FromBody] University_Majors_SubjectGroupDTO university_Majors_SubjectGroupDTO)
        {
            if (university_Majors_SubjectGroupDTO == null)
            {
                university_Majors_SubjectGroupDTO = new University_Majors_SubjectGroupDTO();
            }

            University_Majors university_Majors = new University_Majors
            {
                MajorsId     = university_Majors_SubjectGroupDTO.MajorsId,
                UniversityId = university_Majors_SubjectGroupDTO.UniversityId,
                Year         = university_Majors_SubjectGroupDTO.Year
            };

            university_Majors = await University_MajorsService.Create(university_Majors);

            if (university_Majors.Id == Guid.Empty)
            {
                var university_Majors_ = await University_MajorsService.List(new University_MajorsFilter
                {
                    MajorsId     = university_Majors.MajorsId,
                    UniversityId = university_Majors.UniversityId,
                    Year         = new StringFilter {
                        Equal = university_Majors.Year
                    }
                });

                university_Majors = university_Majors_.FirstOrDefault();
            }

            University_Majors_SubjectGroup university_Majors_SubjectGroup = new University_Majors_SubjectGroup
            {
                SubjectGroupId      = university_Majors_SubjectGroupDTO.SubjectGroupId,
                University_MajorsId = university_Majors.Id,
                Benchmark           = university_Majors_SubjectGroupDTO.Benchmark,
                Quantity            = university_Majors_SubjectGroupDTO.Quantity,
                Note = university_Majors_SubjectGroupDTO.Note
            };

            university_Majors_SubjectGroup = await University_Majors_SubjectGroupService.Create(university_Majors_SubjectGroup);

            university_Majors_SubjectGroupDTO = new University_Majors_SubjectGroupDTO
            {
                MajorsId            = university_Majors_SubjectGroup.MajorsId,
                MajorsCode          = university_Majors_SubjectGroup.MajorsCode,
                MajorsName          = university_Majors_SubjectGroup.MajorsName,
                UniversityId        = university_Majors_SubjectGroup.UniversityId,
                UniversityCode      = university_Majors_SubjectGroup.UniversityCode,
                UniversityName      = university_Majors_SubjectGroup.UniversityName,
                SubjectGroupId      = university_Majors_SubjectGroup.SubjectGroupId,
                SubjectGroupCode    = university_Majors_SubjectGroup.SubjectGroupCode,
                SubjectGroupName    = university_Majors_SubjectGroup.SubjectGroupName,
                University_MajorsId = university_Majors_SubjectGroup.University_MajorsId,
                Quantity            = university_Majors_SubjectGroup.Quantity,
                Note      = university_Majors_SubjectGroup.Note,
                Benchmark = university_Majors_SubjectGroup.Benchmark,
                Id        = university_Majors_SubjectGroup.Id,
                Year      = university_Majors_SubjectGroup.Year,
                Errors    = university_Majors_SubjectGroup.Errors
            };
            if (university_Majors_SubjectGroup.HasError)
            {
                return(BadRequest(university_Majors_SubjectGroupDTO));
            }
            return(Ok(university_Majors_SubjectGroupDTO));
        }
Beispiel #16
0
        public async Task <University_Majors> Get(long Id)
        {
            University_Majors University_Majors = await UOW.University_MajorsRepository.Get(Id);

            return(University_Majors);
        }