Beispiel #1
0
 /// <summary>
 /// Updae Industry AppService
 /// </summary>
 /// <returns>bool<bool></returns>
 public async Task <bool> UpdateIndustry(GradeUpdateDTO industryUpdateDTO)
 {
     #region Declare a return type with initial value.
     bool isUpdated = false;
     #endregion
     try
     {
         if (industryUpdateDTO != null)
         {
             isUpdated = await IndustryBusinessMapping.UpdateIndustry(industryUpdateDTO);
         }
     }
     catch (Exception exception) {}
     return(isUpdated);
 }
Beispiel #2
0
 /// <summary>
 /// Mapping User Activity Log DTO to Action
 /// </summary>
 /// <param name=></param>
 /// <param name=></param>
 /// <returns></returns>
 public Grade MappingGradeupdateDTOToGrade(Grade grade, GradeUpdateDTO GradeUpdateDTO)
 {
     #region Declare Return Var with Intial Value
     Grade Grade = grade;
     #endregion
     try
     {
         if (GradeUpdateDTO.GradeId > default(int))
         {
             Grade.GradeId   = GradeUpdateDTO.GradeId;
             Grade.GradeName = GradeUpdateDTO.GradeName;
         }
     }
     catch (Exception exception) { }
     return(Grade);
 }
 /// <summary>
 /// Mapping User Activity Log DTO to Action
 /// </summary>
 /// <param name="></param>
 /// <param name="></param>
 /// <returns></returns>
 public Industry MappingIndustryupdateDTOToIndustry(Industry industry, GradeUpdateDTO IndustryUpdateDTO)
 {
     #region Declare Return Var with Intial Value
     Industry Industry = industry;
     #endregion
     try
     {
         if (IndustryUpdateDTO.IndustryId > default(int))
         {
             Industry.IndustryId   = IndustryUpdateDTO.IndustryId;
             Industry.IndustryName = IndustryUpdateDTO.IndustryName;
         }
     }
     catch (Exception exception) {}
     return(Industry);
 }
Beispiel #4
0
        /// <summary>
        /// Update User Action Activity Log
        /// </summary>
        /// <param name="></param>
        /// <returns>bool</returns>
        public async Task <bool> UpdateIndustry(GradeUpdateDTO IndustryUpdateDTO)
        {
            #region Declare a return type with initial value.
            bool isIndustryUpdated = default(bool);
            #endregion
            try
            {
                if (IndustryUpdateDTO != null)
                {
                    #region Vars
                    Industry Industry = null;
                    #endregion
                    #region Get Activity By Id
                    Industry = await UnitOfWork.IndustryRepository.GetById(1);

                    #endregion
                    if (Industry != null)
                    {
                        #region  Mapping
                        Industry = IndustryMapping.MappingIndustryupdateDTOToIndustry(Industry, IndustryUpdateDTO);
                        #endregion
                        if (Industry != null)
                        {
                            #region  Update Entity
                            UnitOfWork.IndustryRepository.Update(Industry);
                            isIndustryUpdated = await UnitOfWork.Commit() > default(int);

                            #endregion
                        }
                    }
                }
            }
            catch (Exception exception)
            {
            }
            return(isIndustryUpdated);
        }
Beispiel #5
0
        /// <summary>
        /// Update User Action Activity Log
        /// </summary>
        /// <param name=></param>
        /// <returns>bool</returns>
        public async Task <bool> UpdateGrade(GradeUpdateDTO GradeUpdateDTO)
        {
            #region Declare a return type with initial value.
            bool isGradeUpdated = default(bool);
            #endregion
            try
            {
                if (GradeUpdateDTO != null)
                {
                    #region Vars
                    Grade Grade = null;
                    #endregion
                    #region Get Activity By Id
                    Grade = await UnitOfWork.GradeRepository.GetById((byte)GradeUpdateDTO.GradeId);

                    #endregion
                    if (Grade != null)
                    {
                        #region  Mapping
                        Grade = GradeMapping.MappingGradeupdateDTOToGrade(Grade, GradeUpdateDTO);
                        #endregion
                        if (Grade != null)
                        {
                            #region  Update Entity
                            UnitOfWork.GradeRepository.Update(Grade);
                            isGradeUpdated = await UnitOfWork.Commit() > default(int);

                            #endregion
                        }
                    }
                }
            }
            catch (Exception exception)
            {
            }
            return(isGradeUpdated);
        }
        public async Task <ActionResult <CommonAPIResponse <bool> > > UpdateGrade(GradeUpdateDTO GradeUpdateDTO)
        {
            #region Declare return type with initial value.
            JsonResult jsonResult = GetDefaultJsonResult <bool>();
            #endregion

            try
            {
                #region Validate userUpdateDTO for nullability before prepaing the response.
                if (await GradeAppService.UpdateGrade(GradeUpdateDTO))
                {
                    jsonResult = JsonResultResponse(CommonHelper.GetResponseMessage(APIResponseMessage.Success, CurrentLanguagId), true, HttpStatusCode.OK);
                }
                else
                {
                    jsonResult = JsonResultResponse(CommonHelper.GetResponseMessage(APIResponseMessage.InvalidCredentials, CurrentLanguagId), false, HttpStatusCode.BadRequest);
                }
                #endregion
            }
            catch (Exception exception)
            {
            }
            return(jsonResult);
        }