public ActionResult DeleteConfirmed(string id, int row)
{
CSCOAK cSCOAK = db.CSCOAKs.Find(MyHtmlHelpers.ConvertByteStrToId(id), row);
try
{
db.CSCOAKs.Remove(cSCOAK);
db.SaveChanges();
return(new RedirectResult(Url.Action("Edit", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAK.CONO) }) + "#Authorised"));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
cSCOAK.CSCOMSTR = db.CSCOMSTRs.Find(cSCOAK.CONO);
return(View(cSCOAK));
}
public ActionResult Edit([Bind(Include = "PRSCODE,ADDRID,MAILADDR,MAILADDRBool,ADDRTYPE,ADDR1,ADDR2,ADDR3,POSTAL,CITYCODE,STATECODE,CTRYCODE,PHONE1,PHONE2,FAX1,FAX2,REM,STAMP")] CSPRSADDR cSPRSADDR)
{
if (ModelState.IsValid)
{
try
{
cSPRSADDR.STAMP = cSPRSADDR.STAMP + 1;
db.Entry(cSPRSADDR).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Edit", "CSPRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSPRSADDR.PRSCODE) }));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
}
ViewBag.ADDRTYPE = cSPRSADDR.addrtypeList;
ViewBag.CITYCODE = new SelectList(db.HKCITies.OrderBy(x => x.CITYCODE), "CITYCODE", "CITYDESC", cSPRSADDR.CITYCODE);
ViewBag.STATECODE = new SelectList(db.HKSTATEs.OrderBy(x => x.STATECODE), "STATECODE", "STATEDESC", cSPRSADDR.STATECODE);
ViewBag.CTRYCODE = new SelectList(db.HKCTRies.OrderBy(x => x.CTRYCODE), "CTRYCODE", "CTRYDESC", cSPRSADDR.CTRYCODE);
return(View(cSPRSADDR));
}
public ActionResult Create([Bind(Include = "PRSCODE,CTRYCODE,REGTYPE,REGNO,REM,STAMP")] CSPRSREG cSPRSREG)
{
if (ModelState.IsValid)
{
try
{
cSPRSREG.STAMP = 0;
db.CSPRSREGs.Add(cSPRSREG);
db.SaveChanges();
return(RedirectToAction("Edit", "CSPRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSPRSREG.PRSCODE) }));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
}
ViewBag.PRSCODE = MyHtmlHelpers.ConvertByteStrToId(cSPRSREG.PRSCODE);
ViewBag.REGTYPE = new SelectList(db.HKREGTYPEs.Select(x => new { REGTYPE = x.REGTYPE, REGDESC = x.CTRYOPR + " | " + x.REGTYPE }), "REGTYPE", "REGDESC");
ViewBag.CTRYCODE = new SelectList(db.HKCTRies.OrderBy(x => x.CTRYCODE), "CTRYCODE", "CTRYDESC", cSPRSREG.CTRYCODE);
return(View(cSPRSREG));
}
public ActionResult DeleteConfirmed(string id, int row)
{
CSCOSTAT cSCOSTAT = db.CSCOSTATs.Find(MyHtmlHelpers.ConvertByteStrToId(id), row);
db.CSCOSTATs.Remove(cSCOSTAT);
db.SaveChanges();
// return RedirectToAction("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOSTAT.CONO) });
return(new RedirectResult(Url.Action("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOSTAT.CONO) }) + "#Status"));
}
public ActionResult DeleteConfirmed(string id, int seq)
{
CSCOAGM cSCOAGM = db.CSCOAGMs.Find(MyHtmlHelpers.ConvertByteStrToId(id), seq);
db.CSCOAGMs.Remove(cSCOAGM);
db.SaveChanges();
//return RedirectToAction("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAGM.CONO) });
return(new RedirectResult(Url.Action("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAGM.CONO) }) + "#AGM"));
}
public ActionResult DeleteConfirmed(string id, int row)
{
string trno = DeleteRow(db, id, row);
try
{
db.SaveChanges();
return(RedirectToAction("Edit", "CSCNMs", new { id = MyHtmlHelpers.ConvertIdToByteStr(trno) }));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
CSCND cSCND = db.CSCNDs.Find(MyHtmlHelpers.ConvertByteStrToId(id), row);
ViewBag.CASECODE = new SelectList(db.CSCASEs, "CASECODE", "CASEDESC", cSCND.CASECODE);
ViewBag.ITEMTYPE = new SelectList(db.CSITEMs, "ITEMTYPE", "ITEMDESC", cSCND.ITEMTYPE);
return(View(cSCND));
}
public ActionResult Create([Bind(Include = "CONO,SDATE,COSTAT,FILETYPE,FILELOC,SEALLOC,EDATE,ROWNO,STAMP")] CSCOSTAT cSCOSTAT)
{
if (ModelState.IsValid)
{
int lastRowNo = 0;
try
{
lastRowNo = db.CSCOSTATs.Where(m => m.CONO == cSCOSTAT.CONO).Max(n => n.ROWNO);
}
catch (Exception e) { lastRowNo = -1; }
finally { };
cSCOSTAT.STAMP = 1;
cSCOSTAT.EDATE = cSCOSTAT.SDATE.AddDays(30000);
cSCOSTAT.ROWNO = lastRowNo + 1;
db.CSCOSTATs.Add(cSCOSTAT);
UpdatePreviousRow(cSCOSTAT);
db.SaveChanges();
//return RedirectToAction("Details","CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOSTAT.CONO) });
return(new RedirectResult(Url.Action("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOSTAT.CONO) }) + "#Status"));
}
return(View(cSCOSTAT));
}
public ActionResult Create([Bind(Include = "CONO,PRSCODE,DESIG,REM,STAMP")] CSCOPIC cSCOPIC)
{
if (ModelState.IsValid)
{
try
{
cSCOPIC.STAMP = 0;
db.CSCOPICs.Add(cSCOPIC);
db.SaveChanges();
return(new RedirectResult(Url.Action("Edit", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOPIC.CONO) }) + "#Contact"));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
}
cSCOPIC.CSCOMSTR = db.CSCOMSTRs.Find(cSCOPIC.CONO);
ViewBag.PRSCODE = new SelectList(db.CSPRS.Where(x => x.HKCONST.CONSTTYPE == "Individual").OrderBy(x => x.PRSNAME), "PRSCODE", "PRSNAME", cSCOPIC.PRSCODE);
return(View(cSCOPIC));
}
public ActionResult Create([Bind(Include = "CONO,PRSCODE,ADATE,CHGEFFDATE,CHGREM,PRSNAME,NATION,RACE,ADDRID,OCCUPATION,REGCTRY1,REGTYPE1,REGID1,REGCTRY2,REGTYPE2,REGID2,REGCTRY3,REGTYPE3,REGID3,REM,ROWNO,STAMP")] CSCOSECCHG cSCOSECCHG)
{
if (ModelState.IsValid)
{
try
{
int lastRowNo = 0;
try
{
lastRowNo = db.CSCOSECCHGs.Where(m => m.CONO == cSCOSECCHG.CONO && m.PRSCODE == cSCOSECCHG.PRSCODE && m.ADATE == cSCOSECCHG.ADATE).Max(n => n.ROWNO);
}
catch (Exception e) { lastRowNo = 0; }
finally { };
cSCOSECCHG.ROWNO = lastRowNo + 1;
cSCOSECCHG.STAMP = 0;
db.CSCOSECCHGs.Add(cSCOSECCHG);
db.SaveChanges();
return(new RedirectResult(Url.Action("Edit", "CSCOSECs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOSECCHG.CONO), person = cSCOSECCHG.PRSCODE, adate = cSCOSECCHG.ADATE })));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
}
ViewBag.NATION = new SelectList(db.HKNATIONs, "NATION", "NATION", cSCOSECCHG.NATION);
ViewBag.RACE = new SelectList(db.HKRACEs, "RACE", "RACE", cSCOSECCHG.RACE);
ViewBag.CHGREM = new SelectList(db.CSCHGREMs.OrderBy(x => x.CHGREM), "CHGREM", "CHGREM", cSCOSECCHG.CHGREM);
ViewBag.ADDRID = new SelectList(db.CSPRSADDRs.Where(x => x.PRSCODE == cSCOSECCHG.PRSCODE).OrderBy(y => y.ADDRID).Select(z => new { ADDRID = z.ADDRID, MAILDET = z.ADDRID + " | " + z.MAILADDR + " | " + z.ADDRTYPE + " | " + z.ADDR1 + z.ADDR2 + z.ADDR3 }), "ADDRID", "MAILDET", cSCOSECCHG.ADDRID);
ViewBag.REGID1 = new SelectList(db.CSPRSREGs.Where(x => x.PRSCODE == cSCOSECCHG.PRSCODE).Select(x => new { REGNO = x.REGNO, PRSNAME = x.CTRYCODE + " | " + x.REGTYPE + " | " + x.REGNO }), "REGNO", "PRSNAME", cSCOSECCHG.REGID1);
ViewBag.REGID2 = new SelectList(db.CSPRSREGs.Where(x => x.PRSCODE == cSCOSECCHG.PRSCODE).Select(x => new { REGNO = x.REGNO, PRSNAME = x.CTRYCODE + " | " + x.REGTYPE + " | " + x.REGNO }), "REGNO", "PRSNAME", cSCOSECCHG.REGID2);
ViewBag.REGID3 = new SelectList(db.CSPRSREGs.Where(x => x.PRSCODE == cSCOSECCHG.PRSCODE).Select(x => new { REGNO = x.REGNO, PRSNAME = x.CTRYCODE + " | " + x.REGTYPE + " | " + x.REGNO }), "REGNO", "PRSNAME", cSCOSECCHG.REGID3);
return(View(cSCOSECCHG));
}
public ActionResult Create([Bind(Include = "CONO,ARNO,LASTAR,ARTOFILE,FILEDAR,REMINDER1,REM,STAMP")] CSCOAR cSCOAR)
{
if (ModelState.IsValid)
{
if (cSCOAR.FILEDAR != null) // create next year record if AR is filed
{
CSCOAR csRec = createNextYearRecord(cSCOAR);
db.CSCOARs.Add(csRec);
}
db.CSCOARs.Add(cSCOAR);
db.SaveChanges();
//return RedirectToAction("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAR.CONO) });
return(new RedirectResult(Url.Action("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAR.CONO) }) + "#Annual"));
}
return(View(cSCOAR));
}
public ActionResult Create([Bind(Include = "CONO,REFNO,REFDATE,CMSDATE,CMEDATE,PRSCODE,ADDRID,CMNATURE,LS,CMINFO,CMINFOStr,REM,STAMP")] CSCOCM cSCOCM)
{
if (ModelState.IsValid)
{
try
{
cSCOCM.STAMP = 0;
db.CSCOCMs.Add(cSCOCM);
db.SaveChanges();
return(new RedirectResult(Url.Action("Edit", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOCM.CONO) }) + "#Charge"));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
}
ViewBag.PRSCODE = new SelectList(db.CSPRS.OrderBy(x => x.PRSNAME), "PRSCODE", "PRSNAME", cSCOCM.PRSCODE);
ViewBag.ADDRID = new SelectList(db.CSPRSADDRs.Where(x => x.PRSCODE == cSCOCM.PRSCODE).OrderBy(y => y.ADDRID).Select(z => new { ADDRID = z.ADDRID, MAILDET = z.ADDRID + " | " + z.MAILADDR + " | " + z.ADDRTYPE + " | " + z.ADDR1 + z.ADDR2 + z.ADDR3 }), "ADDRID", "MAILDET", cSCOCM.ADDRID);
cSCOCM.CSCOMSTR = db.CSCOMSTRs.Find(cSCOCM.CONO);
return(View(cSCOCM));
}
public ActionResult Edit([Bind(Include = "CONO,SDATE,COSTAT,FILETYPE,FILELOC,SEALLOC,EDATE,ROWNO,STAMP")] CSCOSTAT cSCOSTAT)
{
if (ModelState.IsValid)
{
ASIDBConnection newdb = new ASIDBConnection();
try
{
CSCOSTAT curRec = newdb.CSCOSTATs.Find(cSCOSTAT.CONO, cSCOSTAT.ROWNO);
if (curRec.STAMP == cSCOSTAT.STAMP)
{
cSCOSTAT.STAMP = cSCOSTAT.STAMP + 1;
UpdatePreviousRow(cSCOSTAT);
db.Entry(cSCOSTAT).State = EntityState.Modified;
db.SaveChanges();
// return RedirectToAction("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOSTAT.CONO) });
return(new RedirectResult(Url.Action("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOSTAT.CONO) }) + "#Status"));
}
else
{
ModelState.AddModelError(string.Empty, "Record is modified");
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
finally
{
newdb.Dispose();
}
}
ViewBag.COSTAT = new SelectList(db.CSSTATs, "COSTAT", "COSTAT", cSCOSTAT.COSTAT);
return(View(cSCOSTAT));
}
public ActionResult Edit([Bind(Include = "JOBNO,CASENO,STAGEFR,STAGETO,INDATE,INTIME,OUTDATE,SENDMODE,REM,INIDX,STAMP")] CSJOBST cSJOBST)
{
CSJOBST lastRec = db.CSJOBSTs.Where(x => x.JOBNO == cSJOBST.JOBNO && x.CASENO == cSJOBST.CASENO).OrderByDescending(x => x.INIDX).FirstOrDefault();
if (lastRec.INIDX != cSJOBST.INIDX)
{
ModelState.AddModelError(String.Empty, "Only the latest record can be modified");
}
if (ModelState.IsValid)
{
try
{
//Remove original record --> the way the index is designed make it necessary to remove the record and recreate
CSJOBST recDel = db.CSJOBSTs.Find(cSJOBST.JOBNO, cSJOBST.CASENO, cSJOBST.INDATE, cSJOBST.INTIME);
db.CSJOBSTs.Remove(recDel);
cSJOBST.STAMP = cSJOBST.STAMP + 1;
db.CSJOBSTs.Add(cSJOBST);
CSJOBD cSJOBD = db.CSJOBDs.Find(cSJOBST.JOBNO, cSJOBST.CASENO);
cSJOBD.STAGE = cSJOBST.STAGETO;
cSJOBD.STAGEDATE = cSJOBST.INDATE;
cSJOBD.STAGETIME = cSJOBST.INTIME;
cSJOBD.STAMP = cSJOBD.STAMP + 1;
db.Entry(cSJOBD).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Edit", "CSJOBDs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSJOBST.JOBNO), row = cSJOBST.CASENO, rel = 1 }));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e) { ModelState.AddModelError(string.Empty, e.Message); }
}
ViewBag.SENDMODE = GetSendModeList();
ViewBag.STAGETO = new SelectList(db.CSSTGs.OrderBy(x => x.STAGESEQ), "STAGE", "STAGE");
ViewBag.Title = "Edit Job Case Status ";
return(View("Edit", cSJOBST));
}
public ActionResult Create([Bind(Include = "TRNO,TRID,CASECODE,ITEMTYPE,ITEMDESC,ITEMSPEC,TAXRATE,ITEMAMT1,TAXAMT1,NETAMT1,ITEMAMT2,TAXAMT2,NETAMT2,ITEMAMT,TAXAMT,NETAMT,STAMP")] CSCND cSCND)
{
if (ModelState.IsValid)
{
CSCND lastRec = db.CSCNDs.Where(m => m.TRNO == cSCND.TRNO).OrderByDescending(n => n.TRID).FirstOrDefault();
if (lastRec == null)
{
cSCND.TRID = 1;
}
else
{
cSCND.TRID = lastRec.TRID + 1;
}
db.CSCNDs.Add(cSCND);
CSCNM parent = db.CSCNMs.Find(cSCND.TRNO);
if (parent != null)
{
try
{
CSTRANM cSTRANM = db.CSTRANMs.Find("CSCN", cSCND.TRNO, cSCND.TRID);
if (cSTRANM == null)
{
cSTRANM = new CSTRANM();
cSTRANM.STAMP = 0;
UpdateCSTRANM(parent, cSCND, cSTRANM);
db.CSTRANMs.Add(cSTRANM);
}
else
{
ModelState.AddModelError(string.Empty, "CSTRANM record already Existed");
throw new Exception("CSTRANM record already Existed");
//UpdateCSTRANM(parent, cSCND, cSTRANM);
//db.Entry(cSTRANM).State = EntityState.Modified;
}
db.SaveChanges();
return(RedirectToAction("Edit", "CSCNMs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCND.TRNO) }));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, "Parent Record is missing");
}
}
ViewBag.CASECODE = new SelectList(db.CSCASEs, "CASECODE", "CASEDESC", cSCND.CASECODE);
ViewBag.ITEMTYPE = new SelectList(db.CSITEMs, "ITEMTYPE", "ITEMDESC", cSCND.ITEMTYPE);
return(View("Edit", cSCND));
}
public ActionResult DeleteConfirmed(string id, int seq)
{
try
{
CSCASEFEE cSCASEFEE = db.CSCASEFEEs.Find(MyHtmlHelpers.ConvertByteStrToId(id), seq);
db.CSCASEFEEs.Remove(cSCASEFEE);
db.SaveChanges();
return(new RedirectResult(Url.Action("Details", "CSCASEs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCASEFEE.CASECODE) }) + "#CASEFEE"));
} catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
return(View());
}
public ActionResult Edit([Bind(Include = "CONO,PRSCODE,EFFDATE,TERDATE,ENDDATE,FOLIONO,REM,STAMP")] CSCOSH cSCOSH)
{
if (ModelState.IsValid)
{
try
{
bool changed = false;
CSCOSH csOrig = (CSCOSH)Session["CSCOSH_ORIG"];
if (csOrig.PRSCODE != cSCOSH.PRSCODE)
{
changed = true;
}
cSCOSH.STAMP = cSCOSH.STAMP + 1;
if (changed)
{
CSCOSH csDel = db.CSCOSHes.Find(csOrig.CONO, csOrig.PRSCODE);
db.CSCOSHes.Remove(csDel);
db.CSCOSHes.Add(cSCOSH);
}
else
{
db.Entry(cSCOSH).State = EntityState.Modified;
}
db.SaveChanges();
return(new RedirectResult(Url.Action("Edit", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOSH.CONO) }) + "#Member"));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
}
cSCOSH.CSCOMSTR = db.CSCOMSTRs.Find(cSCOSH.CONO);
ViewBag.PRSCODE = new SelectList(db.CSPRS.OrderBy(x => x.PRSNAME), "PRSCODE", "PRSNAME", cSCOSH.PRSCODE);
cSCOSH.CSCOSHCHGs = db.CSCOSHCHGs.Where(x => x.CONO == cSCOSH.CONO && x.PRSCODE == cSCOSH.PRSCODE).ToList();
return(View(cSCOSH));
}
public ActionResult Edit([Bind(Include = "CONO,AGMNO,LASTFYE,FYETOFILE,FILEDFYE,AGMLAST,AGMEXT,REMINDER1,REMINDER2,REMINDER3,AGMDATE,AGMFILED,REM,STAMP,CIRCDATE")] CSCOAGM cSCOAGM)
{
if (ModelState.IsValid)
{
ASIDBConnection newdb = new ASIDBConnection();
try
{
CSCOAGM curRec = newdb.CSCOAGMs.Find(cSCOAGM.CONO, cSCOAGM.AGMNO);
if (curRec.STAMP == cSCOAGM.STAMP)
{
cSCOAGM.STAMP = cSCOAGM.STAMP + 1;
db.Entry(cSCOAGM).State = EntityState.Modified;
if (cSCOAGM.FILEDFYE != null) // create next year record if AR is filed
{
string sid = cSCOAGM.CONO;
CSCOAGM lastRec = db.CSCOAGMs.Where(m => m.CONO == sid).OrderByDescending(n => n.AGMNO).FirstOrDefault();
if (cSCOAGM.AGMNO == lastRec.AGMNO) // add next year record only if editing the last record
{
CSCOAGM csRec = createNextYearRecord(cSCOAGM);
db.CSCOAGMs.Add(csRec);
}
}
db.SaveChanges();
//return RedirectToAction("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAGM.CONO) });
return(new RedirectResult(Url.Action("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAGM.CONO) }) + "#AGM"));
}
else
{
ModelState.AddModelError(string.Empty, "Record is modified");
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
finally
{
newdb.Dispose();
}
}
return(View(cSCOAGM));
}
public ActionResult Create([Bind(Include = "CONO,PRSCODE,EFFDATE,TERDATE,ENDDATE,FOLIONO,REM,STAMP")] CSCOSH cSCOSH)
{
if (ModelState.IsValid)
{
cSCOSH.STAMP = 0;
try
{
int lastRowNo = 0;
try
{
lastRowNo = db.CSCOSHes.Where(m => m.CONO == cSCOSH.CONO).Max(n => n.FOLIONO);
}
catch (Exception e) { lastRowNo = 0; }
finally { };
cSCOSH.FOLIONO = lastRowNo + 1;
db.CSCOSHes.Add(cSCOSH);
CSCOLASTNO cSCOLASTNO = db.CSCOLASTNOes.Find(cSCOSH.CONO, "SHFOLIO");
if (cSCOLASTNO != null)
{
cSCOLASTNO.LASTNO = cSCOSH.FOLIONO;
db.Entry(cSCOLASTNO).State = EntityState.Modified;
}
db.SaveChanges();
return(new RedirectResult(Url.Action("Edit", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOSH.CONO) }) + "#Member"));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
}
cSCOSH.CSCOMSTR = db.CSCOMSTRs.Find(cSCOSH.CONO);
ViewBag.PRSCODE = new SelectList(db.CSPRS.OrderBy(x => x.PRSNAME), "PRSCODE", "PRSNAME", cSCOSH.PRSCODE);
return(View(cSCOSH));
}
public ActionResult Create([Bind(Include = "CONO,TXCODE,ADATE,RDATE,ENDDATE,REM,ROWNO,STAMP")] CSCOTX cSCOTX)
{
if (ModelState.IsValid)
{
try
{
int lastRowNo = 0;
try
{
lastRowNo = db.CSCOTXes.Where(m => m.CONO == cSCOTX.CONO).Max(n => n.ROWNO);
}
catch (Exception e) { lastRowNo = 0; }
finally { };
cSCOTX.ROWNO = lastRowNo + 1;
cSCOTX.STAMP = 0;
db.CSCOTXes.Add(cSCOTX);
db.SaveChanges();
return(new RedirectResult(Url.Action("Edit", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOTX.CONO) }) + "#TaxAgent"));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
}
cSCOTX.CSCOMSTR = db.CSCOMSTRs.Find(cSCOTX.CONO);
ViewBag.TXCODE = new SelectList(db.CSTXes.OrderBy(x => x.TXDESC), "TXCODE", "TXDESC", cSCOTX.TXCODE);
return(View(cSCOTX));
}
public ActionResult Create([Bind(Include = "CONO,EFFDATE,AK,REM,ENDDATE,ROWNO,STAMP")] CSCOAK cSCOAK)
{
if (ModelState.IsValid)
{
int lastRowNo = 0;
try
{
lastRowNo = db.CSCOAKs.Where(m => m.CONO == cSCOAK.CONO).Max(n => n.ROWNO);
}
catch (Exception e) { lastRowNo = 0; }
finally { };
try
{
cSCOAK.STAMP = 0;
cSCOAK.ENDDATE = new DateTime(3000, 1, 1);
cSCOAK.ROWNO = lastRowNo + 1;
db.CSCOAKs.Add(cSCOAK);
db.SaveChanges();
return(new RedirectResult(Url.Action("Edit", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAK.CONO) }) + "#Authorised"));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
}
cSCOAK.CSCOMSTR = db.CSCOMSTRs.Find(cSCOAK.CONO);
return(View(cSCOAK));
}
public ActionResult Create([Bind(Include = "CONO,REFNO,REFDATE,DEEDDATE,PRSCODE,SECUREAMT,ISSUEAMT,DEBCOND,DEBINFO,DEBINFOStr,REM,STAMP")] CSCODEB cSCODEB)
{
if (ModelState.IsValid)
{
try
{
cSCODEB.STAMP = 0;
db.CSCODEBs.Add(cSCODEB);
db.SaveChanges();
return(new RedirectResult(Url.Action("Edit", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCODEB.CONO) }) + "#Debenture"));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
}
ViewBag.PRSCODE = new SelectList(db.CSPRS.OrderBy(x => x.PRSNAME), "PRSCODE", "PRSNAME", cSCODEB.PRSCODE);
cSCODEB.CSCOMSTR = db.CSCOMSTRs.Find(cSCODEB.CONO);
return(View(cSCODEB));
}
public ActionResult DeleteConfirmed(string id, int row, DateTime indate, string intime)
{
CSJOBST cSJOBST = db.CSJOBSTs.Find(MyHtmlHelpers.ConvertByteStrToId(id), row, indate, intime);
var histRec = db.CSJOBSTs.Where(x => x.JOBNO == cSJOBST.JOBNO && x.CASENO == cSJOBST.CASENO).OrderByDescending(x => x.INIDX);
if (histRec.Count() == 1)
{
ModelState.AddModelError(String.Empty, "Cannot Remove system generated record");
}
CSJOBST lastRec = db.CSJOBSTs.Where(x => x.JOBNO == cSJOBST.JOBNO && x.CASENO == cSJOBST.CASENO).OrderByDescending(x => x.INIDX).FirstOrDefault();
if (lastRec.INIDX != cSJOBST.INIDX)
{
ModelState.AddModelError(String.Empty, "Only the latest record can be modified");
}
if (ModelState.IsValid)
{
try
{
db.CSJOBSTs.Remove(cSJOBST);
// Change CSJOBD to previous state before delete
foreach (CSJOBST item in histRec)
{
if (item.INIDX != lastRec.INIDX)
{
lastRec = item; break;
} // get the previous record before last record
}
CSJOBD cSJOBD = db.CSJOBDs.Find(cSJOBST.JOBNO, cSJOBST.CASENO);
cSJOBD.STAGE = lastRec.STAGETO;
cSJOBD.STAGEDATE = lastRec.INDATE;
cSJOBD.STAGETIME = lastRec.INTIME;
cSJOBD.STAMP = cSJOBD.STAMP + 1;
db.SaveChanges();
return(RedirectToAction("Edit", "CSJOBDs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSJOBST.JOBNO), row = cSJOBST.CASENO, rel = 1 }));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
}
ViewBag.SENDMODE = GetSendModeList();
ViewBag.STAGETO = new SelectList(db.CSSTGs.OrderBy(x => x.STAGESEQ), "STAGE", "STAGE");
ViewBag.Title = "Delete Job Case Status ";
return(View("Edit", cSJOBST));
}
public ActionResult Edit([Bind(Include = "CASECODE,FEEID,ITEMTYPE,ITEMDESC,ITEMSPEC,TAXRATE,ITEMAMT1,TAXAMT1,NETAMT1,ITEMAMT2,TAXAMT2,NETAMT2,ITEMAMT,TAXAMT,NETAMT,STAMP")] CSCASEFEE cSCASEFEE)
{
if (ModelState.IsValid)
{
ASIDBConnection newdb = new ASIDBConnection();
try
{
CSCASEFEE curRec = newdb.CSCASEFEEs.Find(cSCASEFEE.CASECODE, cSCASEFEE.FEEID);
if (curRec.STAMP == cSCASEFEE.STAMP)
{
cSCASEFEE.STAMP = cSCASEFEE.STAMP + 1;
db.Entry(cSCASEFEE).State = EntityState.Modified;
db.SaveChanges();
//return RedirectToAction("Index");
return(new RedirectResult(Url.Action("Details", "CSCASEs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCASEFEE.CASECODE) }) + "#CASEFEE"));
}
else
{
ModelState.AddModelError(string.Empty, "Record is modified");
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
finally
{
newdb.Dispose();
}
}
ViewBag.ITEMTYPE = new SelectList(db.CSITEMs, "ITEMTYPE", "ITEMDESC", cSCASEFEE.ITEMTYPE);
return(View(cSCASEFEE));
}
public ActionResult PostConfirmed(string id, int row)
{
CSJOBD cSJOBD = db.CSJOBDs.Find(MyHtmlHelpers.ConvertByteStrToId(id), row);
CSJOBM cSJOBM = db.CSJOBMs.Find(MyHtmlHelpers.ConvertByteStrToId(id));
try
{
if ((cSJOBD.STAGE == "Complete") || (cSJOBD.STAGE == "Cancel"))
{
cSJOBD.COMPLETE = "Y";
cSJOBD.COMPLETED = DateTime.Today;
cSJOBD.STAMP = cSJOBD.STAMP + 1;
cSJOBM.OKCNT = cSJOBM.OKCNT + 1;
cSJOBM.STAMP = cSJOBM.STAMP + 1;
db.Entry(cSJOBD).State = EntityState.Modified;
db.Entry(cSJOBM).State = EntityState.Modified;
db.SaveChanges();
int rel = (int)Session["CSJOBDrel"];
if (rel == 0)
{
return(RedirectToAction("Edit", "CSJOBMs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSJOBD.JOBNO) }));
}
else
{
int page = (int)Session["CSJOBDPage"];
return(RedirectToAction("Index", "CSJOBDs", new { page = page }));
}
}
else
{
ModelState.AddModelError(string.Empty, "Can Only Post Completed or Cancelled Jobs");
}
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e) { ModelState.AddModelError(string.Empty, e.Message); }
ViewBag.Id = cSJOBD.JOBNO;
ViewBag.Row = cSJOBD.CASENO;
ViewBag.CASECODE = new SelectList(db.CSCASEs.Select(x => new { CASECODE = x.CASECODE, CASEDESC = x.CASECODE + "\t | \t" + x.CASEDESC }), "CASECODE", "CASEDESC", cSJOBD.CASECODE);
ViewBag.Title = "Post Job Case Details ";
ViewBag.page = Session["CSJOBDPage"];
return(View("Edit", cSJOBD));
}
public ActionResult Create([Bind(Include = "CASECODE,FEEID,ITEMTYPE,ITEMDESC,ITEMSPEC,TAXRATE,ITEMAMT1,TAXAMT1,NETAMT1,ITEMAMT2,TAXAMT2,NETAMT2,ITEMAMT,TAXAMT,NETAMT,STAMP")] CSCASEFEE cSCASEFEE)
{
if (ModelState.IsValid)
{
db.CSCASEFEEs.Add(cSCASEFEE);
db.SaveChanges();
return(new RedirectResult(Url.Action("Details", "CSCASEs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCASEFEE.CASECODE) }) + "#CASEFEE"));
}
ViewBag.ITEMTYPE = new SelectList(db.CSITEMs, "ITEMTYPE", "ITEMDESC", cSCASEFEE.ITEMTYPE);
return(View(cSCASEFEE));
}
public ActionResult Create([Bind(Include = "CONO,ARNO,LASTAR,ARTOFILE,FILEDAR,REMINDER1,REM,STAMP,SUBMITAR")] CSCOAR cSCOAR)
{
if (ModelState.IsValid)
{
try
{
if (cSCOAR.FILEDAR != null) // create next year record if AR is filed
{
CSCOAR csRec = createNextYearRecord(cSCOAR);
db.CSCOARs.Add(csRec);
}
db.CSCOARs.Add(cSCOAR);
db.SaveChanges();
//return RedirectToAction("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAR.CONO) });
return(new RedirectResult(Url.Action("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAR.CONO) }) + "#Annual"));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
}
cSCOAR.CSCOMSTR = db.CSCOMSTRs.Find(cSCOAR.CONO);
return(View(cSCOAR));
}
public ActionResult Create([Bind(Include = "CONO,AGMNO,LASTFYE,FYETOFILE,FILEDFYE,AGMLAST,AGMEXT,REMINDER1,REMINDER2,REMINDER3,AGMDATE,AGMFILED,REM,STAMP,CIRCDATE")] CSCOAGM cSCOAGM)
{
if (ModelState.IsValid)
{
db.CSCOAGMs.Add(cSCOAGM);
db.SaveChanges();
//return RedirectToAction("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAGM.CONO) });
return(new RedirectResult(Url.Action("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAGM.CONO) }) + "#AGM"));
}
return(View(cSCOAGM));
}
public ActionResult Create([Bind(Include = "JOBNO,CASENO,STAGEFR,STAGETO,INDATE,INTIME,OUTDATE,SENDMODE,REM,INIDX,STAMP")] CSJOBST cSJOBST)
{
if (ModelState.IsValid)
{
CSJOBD cSJOBD = db.CSJOBDs.Find(cSJOBST.JOBNO, cSJOBST.CASENO);
cSJOBD.STAGE = cSJOBST.STAGETO;
cSJOBD.STAGEDATE = cSJOBST.INDATE;
cSJOBD.STAGETIME = cSJOBST.INTIME;
cSJOBD.STAMP = cSJOBD.STAMP + 1;
CSJOBST lastRec = db.CSJOBSTs.Where(x => x.JOBNO == cSJOBST.JOBNO && x.CASENO == cSJOBST.CASENO).OrderByDescending(x => x.INIDX).FirstOrDefault();
if (lastRec == null)
{
cSJOBST.STAGEFR = "New";
}
else
{
cSJOBST.STAGEFR = lastRec.STAGETO;
lastRec.OUTDATE = cSJOBST.INDATE;
}
cSJOBST.STAMP = 0;
cSJOBST.INIDX = cSJOBST.INDATE.ToString("yyyy/MM/dd") + " " + cSJOBST.INTIME;
try
{
db.CSJOBSTs.Add(cSJOBST);
db.Entry(cSJOBD).State = EntityState.Modified;
if (lastRec != null)
{
db.Entry(lastRec).State = EntityState.Modified;
}
db.SaveChanges();
return(RedirectToAction("Edit", "CSJOBDs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSJOBST.JOBNO), row = cSJOBST.CASENO, rel = 1 }));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
}
ViewBag.STAGETO = new SelectList(db.CSSTGs.OrderBy(x => x.STAGESEQ), "STAGE", "STAGE");
ViewBag.Title = "Edit Job Case Status ";
return(View("Edit", cSJOBST));
}
public ActionResult Create([Bind(Include = "TRNO,VDATE,CONO,COADDRID,ATTN,REM,SEQNO,POSTBool,STAMP")] CSCNM cSCNM)
{
if (ModelState.IsValid)
{
SALASTNO serialTbl = db.SALASTNOes.Find("CSCN");
if (serialTbl != null)
{
CSCOMSTR cSCOMSTR = db.CSCOMSTRs.Find(cSCNM.CONO);
if (cSCOMSTR != null)
{
try
{
string prefix = serialTbl.LASTPFIX;
int MaxNo = serialTbl.LASTNOMAX;
bool AutoGen = serialTbl.AUTOGEN == "Y";
if (AutoGen)
{
serialTbl.LASTNO = serialTbl.LASTNO + 1;
cSCNM.TRNO = serialTbl.LASTNO.ToString("D10");
serialTbl.STAMP = serialTbl.STAMP + 1;
db.Entry(serialTbl).State = EntityState.Modified;
}
cSCNM.STAMP = 1;
// increment company seqno count before using it in transaction
cSCOMSTR.SEQNO = cSCOMSTR.SEQNO + 1;
cSCOMSTR.STAMP = cSCOMSTR.STAMP + 1;
cSCNM.SEQNO = cSCOMSTR.SEQNO;
db.Entry(cSCOMSTR).State = EntityState.Modified;
db.CSCNMs.Add(cSCNM);
db.SaveChanges();
//return Edit(MyHtmlHelpers.ConvertIdToByteStr(cSCNM.TRNO), 1);
return(RedirectToAction("Edit", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCNM.TRNO), page = 1 }));
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
db.CSCNMs.Remove(cSCNM);
ModelState.AddModelError(string.Empty, e.Message);
}
finally
{
}
}
else
{
ModelState.AddModelError(string.Empty, "Unable to find company #");
}
}
}
ViewBag.CSCND = db.CSCNDs.Where(x => x.TRNO == cSCNM.TRNO);
ViewBag.CONAME = db.CSCOMSTRs.Where(x => x.CONO == cSCNM.CONO).Select(y => y.CONAME).FirstOrDefault();
ViewBag.CONO = new SelectList(db.CSCOMSTRs.Select(x => new { CONO = x.CONO, CONAME = x.CONAME + " (" + x.CONO + ")" }).OrderBy(y => y.CONAME), "CONO", "CONAME", cSCNM.CONO);
ViewBag.ATTNDESC = new SelectList(db.CSCOPICs.Where(x => x.CONO == cSCNM.CONO).Select(x => new { PRSNAME = x.CSPR.PRSNAME, PRSDESC = x.CSPR.PRSNAME }).OrderBy(y => y.PRSDESC), "PRSNAME", "PRSDESC", cSCNM.ATTN);
ViewBag.COADDR = new SelectList(db.CSCOADDRs.Where(x => x.CONO == cSCNM.CONO).Select(x => new { COADDR = x.CONO + "|" + x.ADDRID, COADDRDESC = x.ADDRTYPE + " | " + x.MAILADDR + " | " + x.ADDR1 + " " + x.ADDR2 + " " + x.ADDR3 }), "COADDR", "COADDRDESC", cSCNM.COADDR);
ViewBag.Title = "Create Discounted Bill";
return(View("Edit", cSCNM));
}
public ActionResult Edit([Bind(Include = "CONO,ARNO,LASTAR,ARTOFILE,FILEDAR,REMINDER1,REM,STAMP,SUBMITAR")] CSCOAR cSCOAR)
{
if (ModelState.IsValid)
{
ASIDBConnection newdb = new ASIDBConnection();
try
{
CSCOAR curRec = newdb.CSCOARs.Find(cSCOAR.CONO, cSCOAR.ARNO);
if (curRec.STAMP == cSCOAR.STAMP)
{
cSCOAR.STAMP = cSCOAR.STAMP + 1;
db.Entry(cSCOAR).State = EntityState.Modified;
if (cSCOAR.FILEDAR != null) // create next year record if AR is filed
{
string sid = cSCOAR.CONO;
CSCOAR lastRec = db.CSCOARs.Where(m => m.CONO == sid).OrderByDescending(n => n.ARNO).FirstOrDefault();
if (cSCOAR.ARNO == lastRec.ARNO) // add next year record only if editing the last record
{
CSCOAR csRec = createNextYearRecord(cSCOAR);
db.CSCOARs.Add(csRec);
}
}
db.SaveChanges();
//return RedirectToAction("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAR.CONO) });
return(new RedirectResult(Url.Action("Details", "CSCOMSTRs", new { id = MyHtmlHelpers.ConvertIdToByteStr(cSCOAR.CONO) }) + "#Annual"));
}
else
{
ModelState.AddModelError(string.Empty, "Record is modified");
}
}
catch (DbEntityValidationException dbEx)
{
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
//string message = string.Format("{0}:{1}",
// validationErrors.Entry.Entity.ToString(),
// validationError.ErrorMessage);
// raise a new exception nesting
// the current instance as InnerException
ModelState.AddModelError(validationError.PropertyName, validationError.ErrorMessage);
}
}
}
catch (DbUpdateException ex)
{
UpdateException updateException = (UpdateException)ex.InnerException;
if (updateException != null)
{
if (updateException.InnerException != null)
{
var sqlException = (FirebirdSql.Data.FirebirdClient.FbException)updateException.InnerException;
foreach (var error in sqlException.Errors)
{
if (error.Message != null)
{
ModelState.AddModelError(string.Empty, error.Message);
}
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
else
{
ModelState.AddModelError(string.Empty, updateException.Message);
}
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
}
finally
{
newdb.Dispose();
}
}
cSCOAR.CSCOMSTR = db.CSCOMSTRs.Find(cSCOAR.CONO);
return(View(cSCOAR));
}
