Example #1
0
        public WorkFieldDTO GetWorkFieldFromDB(int id)
        {
            {
                ICollection <WorkFieldDTO> outputList = default(ICollection <WorkFieldDTO>);
                WorkFieldDTO output = new WorkFieldDTO();

                try
                {
                    WorkFieldBusiness _WorkFieldBusiness = new WorkFieldBusiness();
                    WorkFieldList     _WorkFieldList     = _WorkFieldBusiness.SelectRows(id, null, null);

                    if (_WorkFieldList != null && _WorkFieldList.Count > 0)
                    //outputList = Mapper.MapUserAsOutput();
                    {
                        // 2- Prepare Mapping Objects (Fill Values from DB)
                        Mapper._WorkFieldList = _WorkFieldList;

                        // 3- Perform Mapping to Output
                        outputList = Mapper.MapWorkFieldAsOutput();

                        if (outputList != null && outputList.Count > 0)
                        {
                            output = outputList.FirstOrDefault();
                        }
                    }
                }
                catch (Exception ex)
                {
                    // Log Exception Here
                    throw; //new Exception(ex.Message);
                }

                return(output);
            }
        }
Example #2
0
        private static WorkFieldDTO mapWorkField(WorkField workField)
        {
            WorkFieldDTO _WorkFieldMap = new WorkFieldDTO();

            _WorkFieldMap = fillWorkFieldDTObyWorkFieldID(workField.Id);
            //  _WorkFieldMap.WorkFieldDTO = fillWorkfieldDTObyCustomerID(workField.Id);

            return(_WorkFieldMap);;
        }
Example #3
0
        public WorkFieldDTO UpdateWorkFieldInDB(WorkFieldDTO workFieldDTO)
        {
            BaseDataAccess _db = new BaseDataAccess();

            using (DbTransaction dbTransaction = _db.CreateTransaction())
            {
                try

                {
                    // 1- Perform Mapping to  Input (for Saving in DB)
                    if (Mapper.MapWorkFieldAsInput(workFieldDTO))
                    {
                        // 2- Select WorkField to be updated
                        WorkFieldBusiness workFieldBusiness = new WorkFieldBusiness();
                        WorkFieldList     workFieldList     = workFieldBusiness.SelectRows(Mapper._WorkField.Id, null, null);

                        if (workFieldList != null && workFieldList.Count > 0)
                        {
                            workFieldList[0].Id     = Mapper._WorkField.Id;
                            workFieldList[0].name   = Mapper._WorkField.name;
                            workFieldList[0].nameAr = Mapper._WorkField.nameAr;


                            // 3- Update WorkField Data by Input Values
                            workFieldBusiness = new WorkFieldBusiness();
                            if (workFieldBusiness.UpdateRow(dbTransaction, workFieldList[0]) > 0)
                            {
                                dbTransaction.Commit();
                            }

                            else
                            {
                                dbTransaction.Rollback();
                                throw new Exception("DataBase Operation Failure");
                            }
                        }
                        else
                        {
                            dbTransaction.Rollback();
                            throw new Exception("WorkField Id Not Found in DB");
                        }
                    }
                    else
                    {
                        throw new ArgumentNullException("workFieldDTO");
                    }
                }
                catch (Exception ex)
                {
                    dbTransaction.Rollback();
                    throw;
                }
            }

            return(workFieldDTO);
        }
Example #4
0
 public WorkFieldDTO UpdateWorkField(WorkFieldDTO workFieldDTO)
 {
     try
     {
         return(_IWorkFieldDAL.UpdateWorkFieldInDB(workFieldDTO));
     }
     catch (Exception)
     {
         throw;
     }
 }
Example #5
0
 public WorkFieldDTO AddWorkField(WorkFieldDTO workFieldDTO)
 {
     try
     {
         return(_IWorkFieldDAL.AddWorkFieldToDB(workFieldDTO));
     }
     catch (Exception)
     {
         throw;
     }
 }
        public HttpResponseMessage GetWorkFieldByIdentity(int id)
        {
            try
            {
                WorkFieldDTO _Output = _IWorkFieldBLL.GetWorkFieldByID(id);

                return(Request.CreateResponse(HttpStatusCode.OK, _Output));
            }
            catch (Exception ex)
            {
                return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
            }
        }
Example #7
0
        private static WorkFieldDTO fillWorkfieldDTObyCustomerID(int id)
        {
            WorkFieldDTO workFieldDTO = default(WorkFieldDTO); //new WorkFieldDTO();
            WorkField    _WorkField   = _WorkFieldList.FirstOrDefault(i => i.Id == id);

            if (_WorkField != default(WorkField))
            {
                workFieldDTO        = new WorkFieldDTO();
                workFieldDTO.Id     = _WorkField.Id;
                workFieldDTO.name   = _WorkField.name;
                workFieldDTO.nameAr = _WorkField.nameAr;
            }

            return(workFieldDTO);
        }
        public HttpResponseMessage UpdateWorkField(WorkFieldDTO workFieldDTO)
        {
            try
            {
                if (workFieldDTO == null)
                {
                    throw new ArgumentNullException("workFieldDTO");
                }

                WorkFieldDTO _Output = _IWorkFieldBLL.UpdateWorkField(workFieldDTO);
                return(Request.CreateResponse(HttpStatusCode.OK, _Output));
            }
            catch (Exception ex)
            {
                return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
            }
        }
Example #9
0
        private static WorkFieldDTO fillWorkFieldDTObyWorkFieldID(int?WorkFieldID)
        {
            {
                WorkFieldDTO _WorkFieldDTO = default(WorkFieldDTO);
                WorkField    _WorkField    = _WorkFieldList.FirstOrDefault(i => i.Id == WorkFieldID.Value);

                if (_WorkField != default(WorkField))
                {
                    _WorkFieldDTO        = new WorkFieldDTO();
                    _WorkFieldDTO.Id     = _WorkField.Id;
                    _WorkFieldDTO.name   = _WorkField.name;
                    _WorkFieldDTO.nameAr = _WorkField.nameAr;
                }

                return(_WorkFieldDTO);
            }
        }
Example #10
0
        public static ICollection <WorkFieldDTO> MapWorkFieldAsOutput()
        {
            {
                List <WorkFieldDTO> _WorkFieldDTOList = new List <WorkFieldDTO>();
                WorkFieldDTO        _WorkFieldDTO     = default(WorkFieldDTO);

                if (_WorkFieldList != null && _WorkFieldList.Count > 0)
                {
                    foreach (WorkField __WorkField in _WorkFieldList)
                    {
                        _WorkFieldDTO = mapWorkField(__WorkField);
                        _WorkFieldDTOList.Add(_WorkFieldDTO);
                    }
                }

                return(_WorkFieldDTOList);
            }
        }
Example #11
0
        WorkFieldDTO IWorkFieldDAL.AddWorkFieldToDB(WorkFieldDTO workFieldDTO)
        {
            BaseDataAccess _db = new BaseDataAccess();

            using (DbTransaction dbTransaction = _db.CreateTransaction())
            {
                try
                {
                    // 1- Perform Mapping to  Input (for Saving in DB)
                    if (Mapper.MapWorkFieldAsInput(workFieldDTO))
                    {
                        // 2- Insert WorkField  in DB
                        WorkFieldBusiness workFieldBusiness = new WorkFieldBusiness();
                        if (workFieldBusiness.InsertRow(dbTransaction, Mapper._WorkField) > 0)
                        {
                            dbTransaction.Commit();
                            workFieldDTO.Id = Mapper._WorkField.Id;
                        }

                        else
                        {
                            dbTransaction.Rollback();
                            throw new DataException("DataBase Operation Failure");
                        }
                    }
                    else
                    {
                        throw new ArgumentNullException("workFieldDTO");
                    }
                }
                catch (Exception ex)
                {
                    dbTransaction.Rollback();
                    throw;
                }
            }

            return(workFieldDTO);
        }
Example #12
0
        public static bool MapWorkFieldAsInput(WorkFieldDTO workFieldDTO)
        {
            bool result = default(bool);

            _WorkField = new WorkField();


            if (workFieldDTO != null)
            {
                // WorkField Data part

                _WorkField.Id     = workFieldDTO.Id;
                _WorkField.name   = workFieldDTO.name;
                _WorkField.nameAr = workFieldDTO.nameAr;



                result = true;
            }

            return(result);
        }