Esempio n. 1
0
        public async Task <IActionResult> GetIgstByCode([FromBody] IgstMasterModel editIgstMaster)
        {
            ServiceResponseModel <IgstMasterModel> response = new ServiceResponseModel <IgstMasterModel>();

            try
            {
                if (editIgstMaster.IgstId < 0)
                {
                    throw new ArgumentNullException("igstId is required");
                }
                response = await _igstService.GetIgstByCode(editIgstMaster.IgstId);

                if (response.Data == null)
                {
                    return(NotFound(response));
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.StackTrace);
                response.Success = false;
                response.Message = ex.Message;
            }
            return(Ok(response));
        }
Esempio n. 2
0
        public async Task <IActionResult> Add([FromBody] IgstMasterModel newIgstMaster)
        {
            ServiceResponseModel <IgstMasterModel> response = new ServiceResponseModel <IgstMasterModel>();

            try
            {
                if (newIgstMaster.IgstId < 0)
                {
                    throw new ArgumentNullException("IgstId is required");
                }
                if (string.IsNullOrWhiteSpace(newIgstMaster.IgstDetail))
                {
                    throw new ArgumentNullException("IgstDetail is required");
                }

                response = await _igstService.Add(newIgstMaster);

                if (response.Data == null)
                {
                    return(NotFound(response));
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.StackTrace);
                response.Success = false;
                response.Message = ex.Message;
            }
            return(Ok(response));
        }
Esempio n. 3
0
        public async Task <ServiceResponseModel <IgstMasterModel> > GetIgstByCode(int igstId)
        {
            IgstMaster dbIgstMaster = await UnitOfWork.IgstMasters.GetIgstByCode(igstId);

            IgstMasterModel igstMasterModel = _mapper.Map <IgstMasterModel>(dbIgstMaster);
            ServiceResponseModel <IgstMasterModel> serviceResponse = new ServiceResponseModel <IgstMasterModel> {
                Data = igstMasterModel
            };

            return(serviceResponse);
        }
Esempio n. 4
0
        public async Task <ServiceResponseModel <IgstMasterModel> > Add(IgstMasterModel newIgstMaster)
        {
            ServiceResponseModel <IgstMasterModel> serviceResponse = new ServiceResponseModel <IgstMasterModel>();
            IgstMaster igstMaster = _mapper.Map <IgstMaster>(newIgstMaster);
            await UnitOfWork.IgstMasters.AddAsync(igstMaster);

            await UnitOfWork.Complete();

            serviceResponse.Data = newIgstMaster;
            return(serviceResponse);
        }
Esempio n. 5
0
        public async Task <ServiceResponseModel <IgstMasterModel> > Edit(IgstMasterModel editIgstMasterModel)
        {
            ServiceResponseModel <IgstMasterModel> serviceResponse = new ServiceResponseModel <IgstMasterModel>();

            IgstMaster editIgstMaster = await UnitOfWork.IgstMasters.SingleOrDefaultAsync(s => s.IgstId == editIgstMasterModel.IgstId);

            _mapper.Map <IgstMasterModel, IgstMaster>(editIgstMasterModel, editIgstMaster);
            serviceResponse.Data = editIgstMasterModel;
            UnitOfWork.IgstMasters.Update(editIgstMaster);
            await UnitOfWork.Complete();

            return(serviceResponse);
        }
Esempio n. 6
0
        public async Task <ServiceResponseModel <IgstMasterModel> > Delete(int igstId)
        {
            ServiceResponseModel <IgstMasterModel> serviceResponse = new ServiceResponseModel <IgstMasterModel>();
            IgstMaster delIgstMaster = await UnitOfWork.IgstMasters.SingleOrDefaultAsync(s => s.IgstId == igstId);

            UnitOfWork.IgstMasters.Remove(delIgstMaster);
            await UnitOfWork.Complete();

            IgstMasterModel delIgstMasterModel = _mapper.Map <IgstMasterModel>(delIgstMaster);

            serviceResponse.Data = delIgstMasterModel;

            return(serviceResponse);
        }
Esempio n. 7
0
        public async Task <IActionResult> GetAll([FromQuery] PageParams pageParams, [FromBody] IgstMasterModel getIgstMaster)
        {
            ServiceResponseModel <IEnumerable <IgstMaster> > response = new ServiceResponseModel <IEnumerable <IgstMaster> >();

            try
            {
                var igstList = await _igstService.GetAll(pageParams, getIgstMaster);

                Response.AddPaginationHeader(igstList.CurrentPage, igstList.PageSize, igstList.TotalCount, igstList.TotalPages);
                response.Data = igstList;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex.StackTrace);
                response.Success = false;
                response.Message = ex.Message;
            }
            return(Ok(response));
        }
Esempio n. 8
0
        public async Task <PagedList <IgstMaster> > GetAll(PageParams pageParams, IgstMasterModel getIgstMaster)
        {
            var query = _context.IgstMasters.AsQueryable();

            switch (getIgstMaster.OrderBy)
            {
            case "igstDetail":
                query = query.OrderBy(c => c.IgstDetail);
                break;

            case "igstRate":
                query = query.OrderBy(c => c.IgstRate);
                break;

            default:
                query = query.OrderBy(c => c.IgstId);
                break;
            }

            return(await PagedList <IgstMaster> .CreateAsync(query, pageParams.PageNumber, pageParams.PageSize));
        }