public List <MenuAuthentication> GetMenuAuthentication(string userId)
{
List <MenuAuthentication> menuAuthenList = null;
MenuAuthentication menuAuthen;
try
{
ProcParam procPara = new ProcParam(2);
procPara.ProcedureName = "ADMINISTRATOR_PACK.GETMENUAUTHENTICATION";
procPara.AddParamRefCursor(0, "io_cursor");
procPara.AddParamInput(1, "strUserId", userId);
OraDataReader.Instance.OraReader = GlobalDB.Instance.DataAc.ExecuteDataReader(procPara);
////this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
if (OraDataReader.Instance.OraReader.HasRows)
{
menuAuthenList = new List <MenuAuthentication>();
OraDataReader.Instance.OraReader.FetchSize = OraDataReader.Instance.OraReader.RowSize * 1000;
while (OraDataReader.Instance.OraReader.Read())
{
menuAuthen = new MenuAuthentication();
menuAuthen.ProgramType = OraDataReader.Instance.GetString("PROG_TYPE");
menuAuthen.ProgramTypeName = OraDataReader.Instance.GetString("PROG_TYPE_NAME");
menuAuthen.ProgramTypeImage = OraDataReader.Instance.GetString("PROG_TYPE_ICON");
menuAuthen.ProgramID = OraDataReader.Instance.GetString("PROG_ID");
menuAuthen.ProgramKey = OraDataReader.Instance.GetString("PROG_KEY");
menuAuthen.ProgramName = OraDataReader.Instance.GetString("PROG_NAME");
menuAuthen.IconImage = OraDataReader.Instance.GetString("ICON");
menuAuthenList.Add(menuAuthen);
}
}
// always call Close when done reading.
OraDataReader.Instance.Close();
}
catch (Exception ex)
{
menuAuthenList = null;
}
return(menuAuthenList);
}
public string UpdateMTLType(MaterialType mtlType, string userid)
{
string resultMsg = string.Empty;
try
{
ProcParam param = new ProcParam(6);
param.ProcedureName = "MASTER_PACK.M_MTL_TYPE_UPD";
param.AddParamInput(0, "strSEQ_NO", mtlType.SEQ_NO);
param.AddParamInput(1, "strNAME", mtlType.NAME);
param.AddParamInput(2, "strREMARK", mtlType.REMARK);
param.AddParamInput(3, "strREC_STAT", (mtlType.REC_STAT ? "Y" : "N"));
param.AddParamInput(4, "strUSER_ID", userid);
param.AddParamOutput(5, "RESULTMSG", OracleDbType.Varchar2, 255);
GlobalDB.Instance.DataAc.ExecuteNonQuery(param);
////this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
OracleString result = (OracleString)param.ReturnValue(5);
if (!result.IsNull)
{
resultMsg = result.Value;
}
}
catch (Exception ex)
{
throw ex;
}
return(resultMsg);
}
public DataTable PostWorkTicketInterface(int seq, string userid, out string seqno)
{
DataTable dtResult = null;
try
{
ProcParam param = new ProcParam(4)
{
ProcedureName = "INTERFACE_PACK.POST_JOB_WORKTICKET_SAGE50"
};
param.AddParamRefCursor(0, "IO_CURSOR");
param.AddParamOutput(1, "strSEQ_NO", OracleDbType.Varchar2, 30);
param.AddParamInput(2, "strSEQ", seq);
param.AddParamInput(3, "strUSER_ID", userid);
dtResult = GlobalDB.Instance.DataAc.GetDataTable(param, 1000);
OracleString resultDB = (OracleString)param.ReturnValue(1);
if (!resultDB.IsNull)
{
seqno = resultDB.Value;
}
else
{
seqno = string.Empty;
}
}
catch (Exception ex)
{
dtResult = null;
throw ex;
}
return(dtResult);
}
public DataTable StockAsOn(string whid, string product)
{
DataTable dtResult = null;
try
{
ProcParam param = new ProcParam(3);
param.ProcedureName = "QUERY_PACK.STOCK_AS_ON";
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strWH_ID", whid);
param.AddParamInput(2, "strPRODUCT", product);
dtResult = GlobalDB.Instance.DataAc.GetDataTable(param, 1000);
//this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
}
catch (Exception ex)
{
dtResult = null;
throw ex;
}
return(dtResult);
}
public DataTable JobTrackingDetail(string jobNo, string jobLot)
{
DataTable dtResult = null;
try
{
ProcParam param = new ProcParam(3);
param.ProcedureName = "QUERY_PACK.JOB_TRACKING_DTL";
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strJOB_NO", jobNo);
param.AddParamInput(2, "strJOB_LOT", jobLot);
dtResult = GlobalDB.Instance.DataAc.GetDataTable(param, 1000);
//this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
}
catch (Exception ex)
{
dtResult = null;
throw ex;
}
return(dtResult);
}
public DataTable GetCompletedTO(string tono, string userid)
{
DataTable dtResult = null;
try
{
ProcParam param = new ProcParam(3)
{
ProcedureName = "TO_PACK.GET_TO_CSV"
};
param.AddParamRefCursor(0, "IO_CURSOR");
param.AddParamInput(1, "strTO_NO", tono);
param.AddParamInput(2, "strUSER_ID", userid);
dtResult = GlobalDB.Instance.DataAc.GetDataTable(param, 1000);
}
catch (Exception ex)
{
dtResult = null;
throw ex;
}
return(dtResult);
}
public ResponseResult UpdateMixedQty(string serialno, string mixedno, decimal mixQty)
{
response = new ResponseResult();
try
{
ProcParam procPara = new ProcParam(4)
{
ProcedureName = "SCANNER_MAT_CHK_PACK.UPDATE_MIXED_QTY"
};
procPara.AddParamInput(0, "strMIXED_NO", mixedno);
procPara.AddParamInput(1, "strSERIAL_NO", serialno);
procPara.AddParamInput(2, "strMIXED_QTY", mixQty);
procPara.AddParamOutput(3, "RESULTMSG", OracleDbType.Varchar2, 255);
GlobalDB.Instance.DataAc.ExecuteNonQuery(procPara);
if (GlobalDB.Instance.DataAc.LastException != null)
{
throw GlobalDB.Instance.DataAc.LastException;
}
var resultMsg = (OracleString)procPara.ReturnValue(3);
response.Message = resultMsg.ToString();
response.Data = string.Empty;
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
response.Data = string.Empty;
}
return(response);
}
public string UserChangePassword(string password, string userid)
{
string result = string.Empty;
try
{
ProcParam param = new ProcParam(3);
param.ProcedureName = "ADMINISTRATOR_PACK.USER_CHANGE_PASSWORD";
param.AddParamInput(0, "strUSER_ID", userid);
param.AddParamInput(1, "strNewPwd", password);
param.AddParamOutput(2, "RESULTMSG", OracleDbType.NVarchar2, 255, "OK");
GlobalDB.Instance.DataAc.ExecuteNonQuery(param);
////this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
OracleString resultDB = (OracleString)param.ReturnValue(2);
if (!resultDB.IsNull)
{
result = resultDB.Value;
}
else
{
throw GlobalDB.Instance.DataAc.LastException;
}
}
catch (Exception ex)
{
throw ex;
}
return(result);
}
public User GetUserByUserID(string userID)
{
User user = null;
try
{
ProcParam param = new ProcParam(2);
param.ProcedureName = "ADMINISTRATOR_PACK.GET_USER_LIST";
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strUSER_ID", userID);
OraDataReader.Instance.OraReader = GlobalDB.Instance.DataAc.ExecuteDataReader(param);
////this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
if (OraDataReader.Instance.HasRows)
{
OraDataReader.Instance.OraReader.FetchSize = OraDataReader.Instance.OraReader.RowSize * 1;
while (OraDataReader.Instance.OraReader.Read())
{
//Console.WriteLine(reader.GetInt32(0) + ", " + myReader.GetString(1));
user = new User();
user.USER_ID = OraDataReader.Instance.GetString("USER_ID");
user.USER_NAME = OraDataReader.Instance.GetString("USER_NAME");
user.WARE_ID = OraDataReader.Instance.GetString("WARE_ID");
user.LOGIN = OraDataReader.Instance.GetString("LOGIN");
user.PWD = OraDataReader.Instance.GetString("PWD");
user.EMPLOYEE_ID = OraDataReader.Instance.GetString("EMPLOYEE_ID");
user.ROLE_ID = OraDataReader.Instance.GetString("ROLE_ID");
user.REMARK = OraDataReader.Instance.GetString("REMARK");
user.REC_STAT = OraDataReader.Instance.GetString("REC_STAT").ToUpper().Equals("Y");
user.EMAIL = OraDataReader.Instance.GetString("EMAIL");
user.COMP_ID = OraDataReader.Instance.GetString("COMP_ID");
}
}
// always call Close when done reading.
OraDataReader.Instance.Close();
}
catch (Exception ex)
{
user = null;
}
return(user);
}
public Pallet GetPalletDetail(string palletno)
{
Pallet pallet = null;
try
{
ProcParam procPara = new ProcParam(2)
{
ProcedureName = "SCANNER_PACK_FG.GET_PALLET_DETAIL"
};
procPara.AddParamRefCursor(0, "IO_CURSOR");
procPara.AddParamInput(1, "strPALLET_NO", palletno);
OraDataReader.Instance.OraReader = GlobalDB.Instance.DataAc.ExecuteDataReader(procPara);
this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
if (OraDataReader.Instance.OraReader.HasRows)
{
OraDataReader.Instance.OraReader.FetchSize = OraDataReader.Instance.OraReader.RowSize * 100;
while (OraDataReader.Instance.OraReader.Read())
{
pallet = new Pallet();
pallet.PALLET_NO = OraDataReader.Instance.GetString("PALLET_NO");
pallet.SO_NO = OraDataReader.Instance.GetString("SO_NO");
pallet.PALLET_SEQ = OraDataReader.Instance.GetInteger("PALLET_SEQ");
pallet.PALLET_TOTAL = OraDataReader.Instance.GetInteger("PALLET_TOTAL");
pallet.PALLET_STATUS = OraDataReader.Instance.GetString("PALLET_STATUS");
pallet.PALLET_BOX = OraDataReader.Instance.GetInteger("PALLET_BOX");
pallet.PALLET_PCS = OraDataReader.Instance.GetInteger("PALLET_PCS");
}
}
// always call Close when done reading.
OraDataReader.Instance.Close();
}
catch (Exception ex)
{
pallet = null;
throw ex;
}
return(pallet);
}
public DataTable GetRoleProgramByRole(string roleID)
{
List <RoleProgram> lstRoleProg = null;
try
{
ProcParam param = new ProcParam(2);
param.ProcedureName = "ADMINISTRATOR_PACK.GET_ROLE_PROGRAM_LIST";
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strROLE_ID", roleID);
OraDataReader.Instance.OraReader = GlobalDB.Instance.DataAc.ExecuteDataReader(param);
////this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
if (OraDataReader.Instance.HasRows)
{
lstRoleProg = new List <RoleProgram>();
RoleProgram roleProg;
OraDataReader.Instance.OraReader.FetchSize = OraDataReader.Instance.OraReader.RowSize * 1000;
while (OraDataReader.Instance.OraReader.Read())
{
roleProg = new RoleProgram();
roleProg.ROLE_ID = OraDataReader.Instance.GetString("ROLE_ID");
roleProg.PROG_ID = OraDataReader.Instance.GetString("PROG_ID");
roleProg.PROG_NAME = OraDataReader.Instance.GetString("PROG_NAME");
roleProg.REC_STAT = (OraDataReader.Instance.GetString("REC_STAT").ToUpper() == "Y");
roleProg.FLAG = OraDataReader.Instance.GetInteger("FLAG");
lstRoleProg.Add(roleProg);
}
// always call Close when done reading.
OraDataReader.Instance.Close();
}
}
catch (Exception ex)
{
lstRoleProg = null;
}
return(UtilityBLL.ListToDataTable(lstRoleProg, "M_ROLE_PROGRAM"));
}
public List <ProgramType> GetProgramTypeList(string procTypeID)
{
List <ProgramType> lstProcType = null;
ProgramType procType;
try
{
ProcParam param = new ProcParam(2);
param.ProcedureName = "ADMINISTRATOR_PACK.GET_PROGRAM_TYPE_LIST";
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strPROG_TYPE", procTypeID);
OraDataReader.Instance.OraReader = GlobalDB.Instance.DataAc.ExecuteDataReader(param);
////this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
if (OraDataReader.Instance.HasRows)
{
lstProcType = new List <ProgramType>();
OraDataReader.Instance.OraReader.FetchSize = OraDataReader.Instance.OraReader.RowSize * 1000;
while (OraDataReader.Instance.OraReader.Read())
{
//Console.WriteLine(reader.GetInt32(0) + ", " + myReader.GetString(1));
procType = new ProgramType();
procType.PROG_TYPE = OraDataReader.Instance.GetString("PROG_TYPE");
procType.PROG_TYPE_NAME = OraDataReader.Instance.GetString("PROG_TYPE_NAME");
procType.REC_STAT = (OraDataReader.Instance.GetString("REC_STAT").ToUpper() == "Y");
procType.ORDER_BY = OraDataReader.Instance.GetInteger("ORDER_BY");
procType.ICON = OraDataReader.Instance.GetString("ICON");
lstProcType.Add(procType);
}
}
// always call Close when done reading.
OraDataReader.Instance.Close();
}
catch (Exception ex)
{
lstProcType = null;
}
return(lstProcType);
}
public DataTable StockOutSummary(string whid, string partyID, string product, DateTime?fromDate, DateTime?toDate, string shift)
{
DataTable dtResult = null;
try
{
ProcParam param = new ProcParam(7)
{
ProcedureName = "QUERY_PACK.STOCK_OUT_SUM2"
};
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strWH_ID", whid);
param.AddParamInput(2, "strPRODUCT", product);
if (fromDate.HasValue && fromDate.Value != DateTime.MinValue)
{
param.AddParamInput(3, "strDate_from", fromDate.Value);
}
else
{
param.AddParamInput(3, "strDate_from", DBNull.Value);
}
if (toDate.HasValue && toDate.Value != DateTime.MinValue)
{
param.AddParamInput(4, "strDate_to", toDate.Value);
}
else
{
param.AddParamInput(4, "strDate_to", DBNull.Value);
}
param.AddParamInput(5, "strCustomer", partyID);
param.AddParamInput(6, "strShift", shift);
dtResult = GlobalDB.Instance.DataAc.GetDataTable(param, 1000);
//this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
}
catch (Exception ex)
{
dtResult = null;
throw ex;
}
return(dtResult);
}
public DataTable IfInAdjustInList(string postType, string productNo, string postRef, DateTime?fromDate, DateTime?toDate, string userid)
{
DataTable dtResult = null;
try
{
ProcParam param = new ProcParam(7)
{
ProcedureName = "INTERFACE_PACK.QUERY_FG_ADJ"
};
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strDATA_TYPE", postType);
param.AddParamInput(2, "strPROD_NO", productNo);
param.AddParamInput(3, "strPOST_REF ", postRef);
if (fromDate != null)
{
param.AddParamInput(4, "strDATE_FROM", fromDate.Value);
}
else
{
param.AddParamInput(4, "strDATE_FROM", DBNull.Value);
}
if (toDate != null)
{
param.AddParamInput(5, "strDATE_TO", toDate.Value);
}
else
{
param.AddParamInput(5, "strDATE_TO", DBNull.Value);
}
param.AddParamInput(6, "strUser_id ", userid);
dtResult = GlobalDB.Instance.DataAc.GetDataTable(param, 1000);
//this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
}
catch (Exception ex)
{
dtResult = null;
throw ex;
}
return(dtResult);
}
private DataTable GetPrintMachineOrder(int seqNo, string tableName)
{
List <Machine> lstMachine = null;
Machine mc;
try
{
ProcParam param = new ProcParam(2);
param.ProcedureName = "MASTER_PACK.RPT_M_MACHINE_LIST";
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strSEQ_NO", seqNo);
OraDataReader.Instance.OraReader = GlobalDB.Instance.DataAc.ExecuteDataReader(param);
//this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
if (OraDataReader.Instance.OraReader.HasRows)
{
lstMachine = new List <Machine>();
OraDataReader.Instance.OraReader.FetchSize = OraDataReader.Instance.OraReader.RowSize * 1000;
while (OraDataReader.Instance.OraReader.Read())
{
mc = new Machine();
mc.MC_NO = OraDataReader.Instance.GetString("MC_NO");
mc.MACHINE_NAME = OraDataReader.Instance.GetString("MACHINE_NAME");
//mc.BARCODE = UtilityBLL.QRCode_Encode(mc.MC_NO);
lstMachine.Add(mc);
}
}
// always call Close when done reading.
OraDataReader.Instance.Close();
}
catch (Exception ex)
{
lstMachine = null;
throw ex;
}
return(UtilityBLL.ListToDataTable(lstMachine, tableName));
}
public List <Role> GetRoleList()
{
List <Role> lstRole = null;
Role role;
try
{
ProcParam param = new ProcParam(2);
param.ProcedureName = "ADMINISTRATOR_PACK.GET_ROLE_LIST";
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strROLE_ID", string.Empty);
OraDataReader.Instance.OraReader = GlobalDB.Instance.DataAc.ExecuteDataReader(param);
////this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
if (OraDataReader.Instance.HasRows)
{
lstRole = new List <Role>();
OraDataReader.Instance.OraReader.FetchSize = OraDataReader.Instance.OraReader.RowSize * 1000;
while (OraDataReader.Instance.OraReader.Read())
{
//Console.WriteLine(reader.GetInt32(0) + ", " + myReader.GetString(1));
role = new Role();
role.ROLE_ID = OraDataReader.Instance.GetString("ROLE_ID");
role.ROLE_NAME = OraDataReader.Instance.GetString("ROLE_NAME");
role.REC_STAT = (OraDataReader.Instance.GetString("REC_STAT").ToUpper() == "Y");
lstRole.Add(role);
}
}
// always call Close when done reading.
OraDataReader.Instance.Close();
}
catch (Exception ex)
{
lstRole = null;
}
return(lstRole);
}
public DataTable GetUserRoleByUserID(string userID)
{
List <UserRole> lstUserRole = null;
try
{
ProcParam param = new ProcParam(2);
param.ProcedureName = "ADMINISTRATOR_PACK.GET_USER_ROLE_LIST";
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strUSER_ID", userID);
OraDataReader.Instance.OraReader = GlobalDB.Instance.DataAc.ExecuteDataReader(param);
////this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
if (OraDataReader.Instance.HasRows)
{
lstUserRole = new List <UserRole>();
UserRole userRole;
OraDataReader.Instance.OraReader.FetchSize = OraDataReader.Instance.OraReader.RowSize * 1000;
while (OraDataReader.Instance.OraReader.Read())
{
userRole = new UserRole();
userRole.ROLE_ID = OraDataReader.Instance.GetString("ROLE_ID");
userRole.ROLE_NAME = OraDataReader.Instance.GetString("ROLE_NAME");
userRole.REC_STAT = (OraDataReader.Instance.GetString("REC_STAT").ToUpper() == "Y");
userRole.FLAG = OraDataReader.Instance.GetInteger("FLAG");
lstUserRole.Add(userRole);
}
}
// always call Close when done reading.
OraDataReader.Instance.Close();
}
catch (Exception ex)
{
lstUserRole = null;
}
return(UtilityBLL.ListToDataTable(lstUserRole, "M_ROLE_PROGRAM"));
}
public List <Product> Getprod_all_ULP(string prodType)
{
List <Product> lstprod = null;
Product prod;
try
{
ProcParam param = new ProcParam(2)
{
ProcedureName = "UPLOAD_PLAN.SELECT_ALL_PROD"
};
param.AddParamRefCursor(0, "IO_CURSOR");
param.AddParamInput(1, "strProdType", prodType);
OraDataReader.Instance.OraReader = GlobalDB.Instance.DataAc.ExecuteDataReader(param);
if (OraDataReader.Instance.HasRows)
{
lstprod = new List <Product>();
//OraDataReader.Instance.OraReader.FetchSize = OraDataReader.Instance.OraReader.RowSize * 1;
while (OraDataReader.Instance.OraReader.Read())
{
prod = new Product();
prod.PROD_SEQ_NO = OraDataReader.Instance.GetString("PROD_SEQ_NO");
prod.PRODUCT_NO = OraDataReader.Instance.GetString("PRODUCT_NO");
prod.PRODUCT_NAME = OraDataReader.Instance.GetString("PRODUCT_NAME");
prod.MATERIAL_NAME = OraDataReader.Instance.GetString("MATERIAL_TYPE");
//add this field by jack 28-Oct-2016 11:48am
prod.CUST_PROD_NO = OraDataReader.Instance.GetString("PARTY_ID");
lstprod.Add(prod);
}
}
OraDataReader.Instance.Close();
}
catch (Exception ex)
{
string re = ex.Message;
lstprod = null;
}
return(lstprod);
}
public string UploadVendorMaster(DataTable dt, string partyType, string userid)
{
try
{
ProcParam param = new ProcParam(7)
{
ProcedureName = "MASTER_PACK.UPLOAD_PARTY_MASTER"
};
var arrCustomerId = dt.AsEnumerable().ToList().Select(r => r.Field <string>("Vendor ID")).ToArray();
param.AddParamInput(0, "strCUSTOMER_ID", arrCustomerId, OracleDbType.Varchar2);
var arrCustomerName = dt.AsEnumerable().ToList().Select(r => r.Field <string>("Vendor Name")).ToArray();
param.AddParamInput(1, "strCUSTOMER_NAME", arrCustomerName, OracleDbType.Varchar2);
var arrTerm = dt.AsEnumerable().ToList().Select(r => r.Field <string>("Due Days")).ToArray();
param.AddParamInput(2, "strTERM", arrTerm, OracleDbType.Varchar2);
//var arrPriceLevel = dt.AsEnumerable().ToList().Select(r => r.Field<string>("Pricing Level")).ToArray();
//param.AddParamInput(3, "strPRICE_LEVEL", arrPriceLevel, OracleDbType.Varchar2);
param.AddParamInput(3, "strPRICE_LEVEL", ArrayOf <object> .Create(dt.Rows.Count, string.Empty), OracleDbType.Varchar2);
param.AddParamInput(4, "strPARTY_TYPE", ArrayOf <object> .Create(dt.Rows.Count, partyType), OracleDbType.Varchar2);
param.AddParamInput(5, "strUSER_ID", ArrayOf <object> .Create(dt.Rows.Count, userid), OracleDbType.Varchar2);
param.AddParamOutput(6, "RESULTMSG", OracleDbType.Varchar2, 255, "OK", dt.Rows.Count);
GlobalDB.Instance.DataAc.ExecuteNonQuery(param, dt.Rows.Count);
if (GlobalDB.Instance.LastException != null)
{
throw GlobalDB.Instance.LastException;
}
else
{
if (((Oracle.DataAccess.Types.OracleString[])(param.ReturnValue(6)))[0].Value == "OK")
{
return("OK");
}
else
{
return("Error");
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public bool IsNumberOfPalateMaching(string arrNo, out string resultMessage)
{
resultMessage = string.Empty;
string result = string.Empty;
try
{
ProcParam procPara = new ProcParam(3)
{
ProcedureName = "ARRIVAL_PACK.ARR_NUMBER_PTL_MACHING"
};
procPara.AddParamReturn(0, "ReturnValue", OracleDbType.NVarchar2, 100);
procPara.AddParamInput(1, "strARRIVAL_NO", arrNo);
procPara.AddParamOutput(2, "RESULTMSG", OracleDbType.NVarchar2, 255);
GlobalDB.Instance.DataAc.ExecuteNonQuery(procPara);
if (GlobalDB.Instance.LastException != null)
{
throw GlobalDB.Instance.LastException;
}
//inform time
//this.executionTime = oracleData.ExecutionTime;
result = procPara.Parameters[0].Value.ToString().Trim();
resultMessage = procPara.Parameters[2].Value.ToString();
}
catch (Exception ex)
{
resultMessage = ex.Message;
result = "";
}
if (result == "Y")
{
return(true);
}
else
{
return(false);
}
}
public string FGPress_CheckValidationUser(string userid)
{
string result = string.Empty;
try
{
ProcParam procPara = new ProcParam(2)
{
ProcedureName = "SCANNER_PACK_FG_PRESS.USER_VALIDATION"
};
procPara.AddParamReturn(0, "ReturnValue", OracleDbType.Raw, 255);
procPara.AddParamInput(1, "strUSER_ID", userid);
GlobalDB.Instance.DataAc.ExecuteNonQuery(procPara);
if (GlobalDB.Instance.LastException != null)
{
throw GlobalDB.Instance.LastException;
}
this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
//OracleString objResult = (OracleString)procPara.ReturnValue(0);
OracleBinary objResult = (OracleBinary)procPara.ReturnValue(0);
if (!objResult.IsNull)
{
result = UtilityBLL.GetReturnRawData(objResult);
}
else
{
result = string.Empty;
}
}
catch (Exception ex)
{
throw ex;
}
return(result);
}
public int ProductBoxQty(string prodSeq)
{
try
{
ProcParam param = new ProcParam(2);
param.ProcedureName = "INFO.PRODUCT_BOX_QTY";
param.AddParamReturn(0, "ReturnValue", OracleDbType.Decimal, 100);
param.AddParamInput(1, "strNo", prodSeq);
GlobalDB.Instance.DataAc.ExecuteNonQuery(param);
OracleDecimal result = (OracleDecimal)param.ReturnValue(0);
return(result.ToInt32());
}
catch (Exception ex)
{
throw ex;
}
}
//private TimeSpan executionTime;
#endregion
#region Property Member
//public TimeSpan ExecutionTime
//{
// get
// {
// return this.executionTime;
// }
//}
#endregion
public List <Machine> GetActiveMachineList(string mType)
{
List <Machine> lstMc = null;
Machine Mc;
try
{
ProcParam param = new ProcParam(2)
{
ProcedureName = "UPLOAD_PLAN.GET_ACTIVE_MC"
};
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strTYPE", mType);
OraDataReader.Instance.OraReader = GlobalDB.Instance.DataAc.ExecuteDataReader(param);
if (OraDataReader.Instance.OraReader.HasRows)
{
lstMc = new List <Machine>();
OraDataReader.Instance.OraReader.FetchSize = OraDataReader.Instance.OraReader.RowSize * 1000;
while (OraDataReader.Instance.OraReader.Read())
{
Mc = new Machine();
Mc.MC_NO = OraDataReader.Instance.GetString("MC_NO");
Mc.MACHINE_NAME = OraDataReader.Instance.GetString("MACHINE_NAME");
lstMc.Add(Mc);
}
}
// always call Close when done reading.
OraDataReader.Instance.Close();
}
catch (Exception ex)
{
lstMc = null;
throw ex;
}
return(lstMc);
}
public void RemovePrintSEQ(int printSeq)
{
try
{
ProcParam procSEQ = new ProcParam(1);
procSEQ.ProcedureName = "GLOBAL_FUNCTION_PACK.T_PRINT_DEL";
procSEQ.AddParamInput(0, "strSEQ_NO", printSeq);
GlobalDB.Instance.DataAc.ExecuteNonQuery(procSEQ);
////this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
}
catch (Exception ex)
{
printSeq = 0;
}
finally
{
Release();
}
}
public DataTable ProductionSummaryDaily(string productionType, string product, DateTime?fromDate, DateTime?toDate, string shift)
{
DataTable dtResult = null;
try
{
ProcParam param = new ProcParam(6)
{
ProcedureName = "QUERY_PACK.PROD_SUM_DAILY2"
};
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strProdType", productionType);
param.AddParamInput(2, "strPRODUCT", product);
if (fromDate.HasValue && fromDate.Value != DateTime.MinValue)
{
param.AddParamInput(3, "strFGDate_from", fromDate.Value);
}
else
{
param.AddParamInput(3, "strFGDate_from", DBNull.Value);
}
if (toDate.HasValue && toDate.Value != DateTime.MinValue)
{
param.AddParamInput(4, "strFGDate_to", toDate.Value);
}
else
{
param.AddParamInput(4, "strFGDate_to", DBNull.Value);
}
param.AddParamInput(5, "strShift", shift);
dtResult = GlobalDB.Instance.DataAc.GetDataTable(param, 1000);
//this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
}
catch (Exception ex)
{
dtResult = null;
throw ex;
}
return(dtResult);
}
private Bitmap ProductImage(string proSeqNo)
{
Bitmap result = null;
try
{
ProcParam param = new ProcParam(2)
{
ProcedureName = "INFO.MATERIAL_IMAGE"
};
param.AddParamReturn(0, "ReturnValue", OracleDbType.Blob, 255);
param.AddParamInput(1, "strNo", proSeqNo);
GlobalDB.Instance.DataAc.ExecuteNonQuery(param);
//this.executionTime = GlobalDB.Instance.DataAc.ExecuteTime;
OracleBlob blobDB = (OracleBlob)param.ReturnValue(0);
if (!blobDB.IsNull)
{
using (MemoryStream ms = new MemoryStream(blobDB.Value))
{
result = (Bitmap)Bitmap.FromStream(ms);
}
return(result);
}
else
{
return(null);
}
}
catch (Exception ex)
{
throw ex;
}
}
public string CheckValidationUser(string userid, string ipaddress, string serialno, string scanversion)
{
string result = string.Empty;
try
{
ProcParam procPara = new ProcParam(2)
{
ProcedureName = "SCANNER_MAT_CHK_PACK.USER_VALIDATION"
};
procPara.AddParamReturn(0, "ReturnValue", OracleDbType.Raw, 255);
procPara.AddParamInput(1, "strUSER_ID", userid);
GlobalDB.Instance.DataAc.ExecuteNonQuery(procPara);
if (GlobalDB.Instance.DataAc.LastException != null)
{
throw GlobalDB.Instance.DataAc.LastException;
}
OracleBinary objResult = (OracleBinary)procPara.ReturnValue(0);
if (!objResult.IsNull)
{
result = UtilityBLL.GetReturnRawData(objResult);
}
else
{
result = string.Empty;
}
}
catch (Exception ex)
{
throw ex;
}
return(result);
}
public DataTable GetPrintTime(int seq)
{
DataTable dtResult = null;
try
{
ProcParam param = new ProcParam(2)
{
ProcedureName = "MTL_IN_PACK.GET_PRINTED_CARD"
};
param.AddParamRefCursor(0, "io_cursor");
param.AddParamInput(1, "strSEQ_NO", seq);
dtResult = GlobalDB.Instance.DataAc.GetDataTable(param, 1000);
}
catch (Exception ex)
{
dtResult = null;
throw ex;
}
return(dtResult);
}
public DataTable GetProductList(string partyid)
{
DataTable dtbResult;
try
{
ProcParam param = new ProcParam(2)
{
ProcedureName = "MASTER_PACK.GET_PRATY_PRODUCT_LIST"
};
param.AddParamRefCursor(0, "IO_CURSOR");
param.AddParamInput(1, "strPARTY_ID", partyid);
dtbResult = GlobalDB.Instance.DataAc.GetDataTable(param, 1000);
}
catch (Exception ex)
{
dtbResult = null;
}
return(dtbResult);
}
public ResponseResult CheckJobOrder(string jobno)
{
response = new ResponseResult();
try
{
ProcParam procPara = new ProcParam(3)
{
ProcedureName = "SCANNER_MAT_CHK_PACK.CHK_JOB_ORDER"
};
procPara.AddParamReturn(0, "ReturnValue", OracleDbType.Varchar2, 30);
procPara.AddParamInput(1, "strJOB_NO", jobno);
procPara.AddParamOutput(2, "RESULTMSG", OracleDbType.Varchar2, 255);
GlobalDB.Instance.DataAc.ExecuteNonQuery(procPara);
if (GlobalDB.Instance.DataAc.LastException != null)
{
throw GlobalDB.Instance.DataAc.LastException;
}
var returnValue = (OracleString)procPara.ReturnValue(0);
var resultMsg = (OracleString)procPara.ReturnValue(2);
response.Message = resultMsg.ToString();
response.Data = returnValue.ToString();
}
catch (Exception ex)
{
response.Status = false;
response.Message = ex.Message;
response.Data = string.Empty;
}
return(response);
}