Beispiel #1
0
        public virtual IEnumerable <TEntity> Get(
            Expression <Func <TEntity, bool> > filter = null,
            Func <IQueryable <TEntity>, IOrderedQueryable <TEntity> > orderBy = null,
            string includeProperties = "")
        {
            try
            {
                IQueryable <TEntity> query = dbSet;

                if (filter != null)
                {
                    query = query.Where(filter);
                }

                foreach (var includeProperty in includeProperties.Split
                             (new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
                {
                    query = query.Include(includeProperty);
                }

                if (orderBy != null)
                {
                    return(orderBy(query).ToList());
                }
                else
                {
                    return(query.ToList());
                }
            }catch (Exception ex)
            {
                throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
            }
        }
Beispiel #2
0
        public List <T> ResponseTransaction <T>(string service, ref int code)
            where T : class
        {
            List <T> objectResponse = null;

            try
            {
                string json = null;
                using (WebClient wc = new WebClient())
                {
                    json = wc.DownloadString(ConfigurationManager.AppSettings[service].ToString());
                }

                objectResponse = JsonConvert.DeserializeObject <List <T> >(json);

                code = 200;
                return(objectResponse);
            }
            catch (Exception ex)
            {
                code = 500;
                Log.Error(HelperMessage.GetMessage(CodeMessage.INT_001), ex);
                return(objectResponse);
            }
        }
Beispiel #3
0
 public virtual TEntity GetByID(object id)
 {
     try
     {
         return(dbSet.Find(id));
     }
     catch (Exception ex)
     {
         throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
     }
 }
Beispiel #4
0
 public virtual void BulkInsert(List <TEntity> entity)
 {
     try
     {
         context.BulkInsert <TEntity>(entity);
     }
     catch (Exception ex)
     {
         throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
     }
 }
Beispiel #5
0
 public T[] ExecuteSentence <T>(string sentence)
 {
     try
     {
         return(context.Database.SqlQuery <T>(sentence).ToArray());
     }
     catch (Exception ex)
     {
         throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
     }
 }
Beispiel #6
0
 public virtual void AllDelete()
 {
     try
     {
         context.Database.ExecuteSqlCommand($"TRUNCATE TABLE {typeof(TEntity).Name}");
     }
     catch (Exception ex)
     {
         throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
     }
 }
Beispiel #7
0
 public virtual void Insert(TEntity entity)
 {
     try
     {
         dbSet.Add(entity);
     }
     catch (Exception ex)
     {
         throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
     }
 }
Beispiel #8
0
 public virtual void Update(TEntity entityToUpdate)
 {
     try
     {
         dbSet.Attach(entityToUpdate);
         context.Entry(entityToUpdate).State = EntityState.Modified;
     }
     catch (Exception ex)
     {
         throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
     }
 }
Beispiel #9
0
 public virtual void Delete(object id)
 {
     try
     {
         TEntity entityToDelete = dbSet.Find(id);
         Delete(entityToDelete);
     }
     catch (Exception ex)
     {
         throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
     }
 }
        public HttpResponseMessage GetSkuValue(string sku)
        {
            try
            {
                Rate.CalculateConversion("EUR");
                TotalTransaction[]  total    = Transaction.GetSkuValue(sku);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, new Response
                {
                    Code        = CommonConstants.SuccessCode,
                    Description = null,
                    Data        = total
                });
                return(response);
            }
            catch (ExceptionOperation ex)
            {
                Log.Error(ex.Message, ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = ex.Message
                });
                return(response);
            }
            catch (Exception ex)
            {
                Log.Error(HelperMessage.GetMessage(CodeMessage.TRN_001), ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = HelperMessage.GetMessage(CodeMessage.TRN_001)
                });

                return(response);
            }
            finally
            {
                if (Transaction != null)
                {
                    Transaction.Dispose();
                }
                if (Rate != null)
                {
                    Rate.Dispose();
                }
            }
        }
Beispiel #11
0
 public virtual void Delete(TEntity entityToDelete)
 {
     try
     {
         if (context.Entry(entityToDelete).State == EntityState.Detached)
         {
             dbSet.Attach(entityToDelete);
         }
         dbSet.Remove(entityToDelete);
     }
     catch (Exception ex)
     {
         throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
     }
 }
        public HttpResponseMessage SetTransaction()
        {
            try
            {
                Transaction.SetTransaction();
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, new Response
                {
                    Code        = CommonConstants.SuccessCode,
                    Description = null,
                    Data        = null
                });
                return(response);
            }
            catch (ExceptionOperation ex)
            {
                Log.Error(ex.Message, ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = ex.Message
                });
                return(response);
            }
            catch (Exception ex)
            {
                Log.Error(HelperMessage.GetMessage(CodeMessage.TRN_001), ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = HelperMessage.GetMessage(CodeMessage.TRN_001)
                });

                return(response);
            }
            finally
            {
                if (Transaction != null)
                {
                    Transaction.Dispose();
                }
                if (Rate != null)
                {
                    Rate.Dispose();
                }
            }
        }
Beispiel #13
0
        public HttpResponseMessage GetRate()
        {
            try
            {
                IEnumerable <Rate> objectResponse = Rate.GetRate();

                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, new Response
                {
                    Code        = CommonConstants.SuccessCode,
                    Description = null,
                    Data        = objectResponse
                });

                return(response);
            }
            catch (ExceptionOperation ex)
            {
                Log.Error(ex.Message, ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = ex.Message
                });
                return(response);
            }
            catch (Exception ex)
            {
                Log.Error(HelperMessage.GetMessage(CodeMessage.RAT_001), ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = ex.Message
                });
                return(response);
            }
            finally
            {
                if (Rate != null)
                {
                    Rate.Dispose();
                }
            }
        }
Beispiel #14
0
        public int ExecuteProcedure(SqlProcedure procedure)
        {
            try
            {
                StringBuilder query = new StringBuilder();
                query.AppendFormat("{0} {1}"
                                   , procedure.ProcedureName
                                   , string.Join(",", procedure.Parameters.Select(p => p.ParameterName + "=" + p.Value.ToString())));

                var rowsAffected = context
                                   .Database
                                   .ExecuteSqlCommand(query.ToString());

                return(rowsAffected);
            }
            catch (Exception ex)
            {
                throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
            }
        }
Beispiel #15
0
        public T[] ExecuteProcedure <T>(string procedureName)
        {
            try
            {
                StringBuilder query = new StringBuilder();
                query.AppendFormat("{0}"
                                   , procedureName);

                var selectedList = context
                                   .Database
                                   .SqlQuery <T>(query.ToString())
                                   .ToArray <T>();

                return((T[])selectedList);
            }
            catch (Exception ex)
            {
                throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
            }
        }
Beispiel #16
0
        public T[] ExecuteProcedure <T>(SqlProcedure procedure)
        {
            try
            {
                StringBuilder query = new StringBuilder();
                query.AppendFormat("{0} {1}"
                                   , procedure.ProcedureName
                                   , string.Join(",", procedure.Parameters.Select(p => p.ParameterName + "=" + p.Value.ToString())));

                var selectedList = context
                                   .Database
                                   .SqlQuery <T>(query.ToString())
                                   .ToArray <T>();

                return((T[])selectedList);
            }
            catch (Exception ex)
            {
                throw new ExceptionOperation(HelperMessage.GetMessage(CodeMessage.GEN_001), (int)CodeHTTP.Error, ex.Message, ex.InnerException);
            }
        }
Beispiel #17
0
        public HttpResponseMessage GetConvertion(CurrencyConvert target)
        {
            try
            {
                Rate.CalculateConversion(target.Currency);
                TotalTransaction[]  total    = Transaction.GetTotalTransaction();
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, new Response
                {
                    Code        = CommonConstants.SuccessCode,
                    Description = null,
                    Data        = total
                });
                return(response);
            }
            catch (ExceptionOperation ex)
            {
                Log.Error(ex.Message, ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = ex.Message
                });
                return(response);
            }
            catch (Exception ex)
            {
                Log.Error(HelperMessage.GetMessage(CodeMessage.TRN_001), ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = HelperMessage.GetMessage(CodeMessage.TRN_001)
                });

                return(response);
            }
        }
        public HttpResponseMessage SetRate()
        {
            try
            {
                Rate.SetRate();
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, new Response
                {
                    Code        = CommonConstants.SuccessCode,
                    Description = null,
                    Data        = null
                });

                return(response);
            }
            catch (ExceptionOperation ex)
            {
                Log.Error(ex.Message, ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = ex.Message
                });
                return(response);
            }
            catch (Exception ex)
            {
                Log.Error(HelperMessage.GetMessage(CodeMessage.RAT_001), ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = ex.Message
                });
                return(response);
            }
        }
Beispiel #19
0
        public HttpResponseMessage GetTransaction()
        {
            try
            {
                IEnumerable <ProductTransaction> transaction = Transaction.GetTransaction();
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, new Response
                {
                    Code        = CommonConstants.SuccessCode,
                    Description = null,
                    Data        = transaction
                });
                return(response);
            }
            catch (ExceptionOperation ex)
            {
                Log.Error(ex.Message, ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = ex.Message
                });
                return(response);
            }
            catch (Exception ex)
            {
                Log.Error(HelperMessage.GetMessage(CodeMessage.TRN_001), ex);
                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.InternalServerError, new Response
                {
                    Code        = CommonConstants.ErrorCode,
                    Description = null,
                    Data        = ex.Message
                });

                return(response);
            }
        }