Example #1
0
        /// <summary>
        /// GetItem  SAS_ExportData Data...
        /// <summary>
        /// <param name=sender></param>
        /// <param name= e></param>
        public ExportDataEN GetItem(ExportDataEN argEn)
        {
            ExportDataEN loItem = new ExportDataEN();
            string       sqlCmd = "Select * FROM SAS_ExportData WHERE InterfaceID = @InterfaceID";

            Microsoft.Practices.EnterpriseLibrary.Data.Database coDb = DatabaseFactory.CreateDatabase(csConnectionStr);
            try
            {
                using (DbCommand cmd = coDb.GetSqlStringCommand(sqlCmd))
                {
                    coDb.AddInParameter(cmd, "@InterfaceID", DbType.String, argEn.InterfaceID);
                    using (IDataReader loReader = coDb.ExecuteReader(cmd))
                    {
                        if (loReader != null)
                        {
                            loReader.Read();
                            loItem = LoadObject(loReader);
                        }
                        loReader.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(loItem);
        }
Example #2
0
        /// <summary>
        /// Getlist  SAS_ExportData Data...
        /// <summary>
        /// <param name=sender></param>
        /// <param name= e></param>
        public List <ExportDataEN> GetList(ExportDataEN argEn)
        {
            List <ExportDataEN> loEnList = new List <ExportDataEN>();

            argEn.InterfaceID = argEn.InterfaceID.Replace("*", "%");
            string sqlCmd = "select * from SAS_ExportData where Interfaceid <> '0'";

            if (argEn.InterfaceID.Length != 0)
            {
                sqlCmd = sqlCmd + " and Interfaceid like '" + argEn.InterfaceID + "'";
            }
            Microsoft.Practices.EnterpriseLibrary.Data.Database coDb = DatabaseFactory.CreateDatabase(csConnectionStr);
            try
            {
                using (DbCommand cmd = coDb.GetSqlStringCommand(sqlCmd))
                {
                    using (IDataReader loReader = coDb.ExecuteReader(cmd))
                    {
                        while (loReader.Read())
                        {
                            ExportDataEN loItem = LoadObject(loReader);
                            loEnList.Add(loItem);
                        }
                        loReader.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(loEnList);
        }
Example #3
0
        /// <summary>
        /// Delete  SAS_ExportData Data...
        /// <summary>
        /// <param name=sender></param>
        /// <param name= e></param>
        public bool Delete(ExportDataEN argEn)
        {
            bool   lbRes  = false;
            string sqlCmd = "DELETE FROM SAS_ExportData WHERE InterfaceID = @InterfaceID";

            Microsoft.Practices.EnterpriseLibrary.Data.Database coDb = DatabaseFactory.CreateDatabase(csConnectionStr);
            try
            {
                using (DbCommand cmd = coDb.GetSqlStringCommand(sqlCmd))
                {
                    coDb.AddInParameter(cmd, "@InterfaceID", DbType.String, argEn.InterfaceID);
                    int liRowAffected = coDb.ExecuteNonQuery(cmd);
                    if (liRowAffected > -1)
                    {
                        lbRes = true;
                    }
                    else
                    {
                        throw new Exception("Deletion Failed! No Row has been deleted...");
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(lbRes);
        }
Example #4
0
        /// <summary>
        /// GetItem  SAS_ExportData Data...
        /// <summary>
        /// <param name=sender></param>
        /// <param name= e></param>

        public ExportDataEN GetItem(ExportDataEN argEn)
        {
            try
            {
                ExportDataDAL loDs = new ExportDataDAL();
                return(loDs.GetItem(argEn));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #5
0
 /// <summary>
 /// Getlist  SAS_ExportData Data...
 /// <summary>
 /// <param name=sender></param>
 /// <param name= e></param>
 public List <ExportDataEN> GetList(ExportDataEN argEn)
 {
     try
     {
         ExportDataDAL loDs = new ExportDataDAL();
         return(loDs.GetList(argEn));
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #6
0
        /// <summary>
        /// Insert  SAS_ExportData Data...
        /// <summary>
        /// <param name=sender></param>
        /// <param name= e></param>

        public bool Insert(ExportDataEN argEn)
        {
            bool flag;

            try
            {
                ExportDataDAL loDs = new ExportDataDAL();
                return(loDs.Insert(argEn));
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #7
0
 /// <summary>
 /// Method to Load All Active Export Data
 /// </summary>
 private void GetActiveData()
 {
     try
     {
         int           i    = 0;
         ExportDataEN  loen = new ExportDataEN();
         ExportDataDAL lods = new ExportDataDAL();
         loen.InterfaceID = "";
         lolist           = lods.GetList(loen);
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #8
0
        /// <summary>
        /// IsValid  SAS_ExportData Data...
        /// <summary>
        /// <param name=sender></param>
        /// <param name= e></param>

        public bool IsValid(ExportDataEN argEn)
        {
            try
            {
                if (argEn.InterfaceID == null || argEn.InterfaceID.ToString().Length <= 0)
                {
                    throw new Exception("InterfaceID Is Required!");
                }
                return(true);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #9
0
        /// <summary>
        /// Update  SAS_ExportData Data...
        /// <summary>
        /// <param name=sender></param>
        /// <param name= e></param>

        public bool Update(ExportDataEN argEn)
        {
            //bool flag;
            //using (TransactionScope ts = new TransactionScope())
            //{
            try
            {
                ExportDataDAL loDs = new ExportDataDAL();
                return(loDs.Update(argEn));
                //ts.Complete();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            //}
            //return flag;
        }
Example #10
0
        /// <summary>
        /// Delete  SAS_ExportData Data...
        /// <summary>
        /// <param name=sender></param>
        /// <param name= e></param>

        public bool Delete(ExportDataEN argEn)
        {
            bool flag;

            using (TransactionScope ts = new TransactionScope())
            {
                try
                {
                    ExportDataDAL loDs = new ExportDataDAL();
                    flag = loDs.Delete(argEn);
                    ts.Complete();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            return(flag);
        }
Example #11
0
        /// <summary>
        /// Load  SAS_ExportData Data...
        /// <summary>
        /// <param name=sender></param>
        /// <param name= e></param>
        private ExportDataEN LoadObject(IDataReader argReader)
        {
            ExportDataEN loItem = new ExportDataEN();

            loItem.InterfaceID         = GetValue <string>(argReader, "InterfaceID");
            loItem.FileFormat          = GetValue <string>(argReader, "FileFormat");
            loItem.Interface           = GetValue <string>(argReader, "Interface");
            loItem.Frequency           = GetValue <string>(argReader, "Frequency");
            loItem.TimeofExport        = GetValue <string>(argReader, "TimeofExport");
            loItem.Filepath            = GetValue <string>(argReader, "Filepath");
            loItem.PreviousData        = GetValue <bool>(argReader, "PreviousData");
            loItem.PreviousData        = GetValue <bool>(argReader, "DateRange");
            loItem.DateFrom            = GetValue <DateTime>(argReader, "DateFrom");
            loItem.DateTo              = GetValue <DateTime>(argReader, "DateTo");
            loItem.LastUpdatedBy       = GetValue <string>(argReader, "LastUpdatedBy");
            loItem.LastUpdatedDateTime = GetValue <DateTime>(argReader, "LastUpdatedDateTime");

            return(loItem);
        }
Example #12
0
        /// <summary>
        /// DeSerialize an object
        /// </summary>
        /// <param name="xmlOfAnObject"></param>
        /// <returns></returns>
        private object DeSerializeAnObject(string xmlOfAnObject)
        {
            ExportDataEN myObject = new ExportDataEN();

            System.IO.StringReader read = new StringReader(xmlOfAnObject);
            System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(myObject.GetType());
            System.Xml.XmlReader reader = new XmlTextReader(read);
            try
            {
                myObject = (ExportDataEN)serializer.Deserialize(reader);
                return(myObject);
            }
            catch
            {
                throw;
            }
            finally
            {
                reader.Close();
                read.Close();
                read.Dispose();
            }
        }
Example #13
0
 private void MyOperation(object obj)
 {
     lock (this)
     {
         try
         {
             ExportDataEN loexdata = new ExportDataEN();
             loexdata = (ExportDataEN)obj;
             if (loexdata != null)
             {
                 int k = lolist.FindIndex(delegate(ExportDataEN otd) { return(otd.InterfaceID == loexdata.InterfaceID); });
                 if (k != -1)
                 {
                     lolist[k] = loexdata;
                 }
                 else
                 {
                     lolist.Add(loexdata);
                 }
             }
         }
         catch (MessageQueueException ex)
         {
             if (ex.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout)
             {
                 // do nothing
             }
             else
             {
             }
         }
         catch (Exception ex)
         {
             throw ex;
         }
     }
 }
Example #14
0
 /// <summary>
 /// Method to Read ExportData from MSMQ and check the conditions
 /// </summary>
 private void ProcessExportData(ExportDataEN loen)
 {
     ThreadPool.QueueUserWorkItem(new WaitCallback(MyOperation), loen);
 }
Example #15
0
        /// <summary>
        /// Update  SAS_ExportData Data...
        /// <summary>
        /// <param name=sender></param>
        /// <param name= e></param>
        public bool Update(ExportDataEN argEn)
        {
            bool   lbRes  = false;
            int    iOut   = 0;
            string sqlCmd = "Select count(*) as cnt From SAS_ExportData WHERE InterfaceID = '" + argEn.InterfaceID + "'";

            try
            {
                Microsoft.Practices.EnterpriseLibrary.Data.Database loDbSel = DatabaseFactory.CreateDatabase(csConnectionStr);
                using (DbCommand cmdSel = loDbSel.GetSqlStringCommand(sqlCmd))
                {
                    using (IDataReader dr = loDbSel.ExecuteReader(cmdSel))
                    {
                        if (dr.Read())
                        {
                            iOut = GetValue <int>(dr, "cnt");
                        }
                        if (iOut < 0)
                        {
                            throw new Exception("Update Failed! No Record Exist!");
                        }
                    }
                    if (iOut != 0)
                    {
                        sqlCmd = "UPDATE SAS_ExportData SET InterfaceID = @InterfaceID, FileFormat = @FileFormat, Interface = @Interface, Frequency = @Frequency, TimeofExport = @TimeofExport, Filepath = @Filepath, PreviousData = @PreviousData,DateRange = @DateRange, DateFrom = @DateFrom, DateTo = @DateTo, LastUpdatedBy = @LastUpdatedBy, LastUpdatedDateTime = @LastUpdatedDateTime WHERE InterfaceID = @InterfaceID";
                        Microsoft.Practices.EnterpriseLibrary.Data.Database loDbUpd = DatabaseFactory.CreateDatabase(csConnectionStr);
                        using (DbCommand cmd = loDbUpd.GetSqlStringCommand(sqlCmd))
                        {
                            loDbUpd.AddInParameter(cmd, "@InterfaceID", DbType.String, argEn.InterfaceID);
                            loDbUpd.AddInParameter(cmd, "@FileFormat", DbType.String, argEn.FileFormat);
                            loDbUpd.AddInParameter(cmd, "@Interface", DbType.String, argEn.Interface);
                            loDbUpd.AddInParameter(cmd, "@Frequency", DbType.String, argEn.Frequency);
                            loDbUpd.AddInParameter(cmd, "@TimeofExport", DbType.String, argEn.TimeofExport);
                            loDbUpd.AddInParameter(cmd, "@Filepath", DbType.String, argEn.Filepath);
                            loDbUpd.AddInParameter(cmd, "@PreviousData", DbType.Boolean, argEn.PreviousData);
                            loDbUpd.AddInParameter(cmd, "@DateRange", DbType.Boolean, argEn.DateRange);
                            loDbUpd.AddInParameter(cmd, "@DateFrom", DbType.DateTime, argEn.DateFrom);
                            loDbUpd.AddInParameter(cmd, "@DateTo", DbType.DateTime, argEn.DateTo);
                            loDbUpd.AddInParameter(cmd, "@LastUpdatedBy", DbType.String, argEn.LastUpdatedBy);
                            loDbUpd.AddInParameter(cmd, "@LastUpdatedDateTime", DbType.DateTime, argEn.LastUpdatedDateTime);
                            int liRowAffected = loDbUpd.ExecuteNonQuery(cmd);
                            if (liRowAffected > -1)
                            {
                                System.Messaging.Message mm = new System.Messaging.Message(argEn, new System.Messaging.XmlMessageFormatter(new Type[] { typeof(ExportDataEN), typeof(string) }));
                                mm.Label = argEn.InterfaceID;
                                MessageQueueTransaction Transaction = new MessageQueueTransaction();
                                Transaction.Begin();
                                mq.Send(mm, Transaction);
                                Transaction.Commit();
                                lbRes = true;
                            }
                            else
                            {
                                throw new Exception("Update Failed! No Row has been updated...");
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(lbRes);
        }