private void btnUpdateContact_Click(object sender, EventArgs e)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
Data.Models.NextOfKin IndividualToUpdate = (from a in Dbconnection.NextOfKins
where a.IndividualID == IndividualID
select a).FirstOrDefault <Data.Models.NextOfKin>();
IndividualToUpdate.Individual.TitleID = Convert.ToInt32(cboIndividualTitle.SelectedValue);
IndividualToUpdate.Individual.IndividualFirstName = txtFirstName.Text.ToString();
IndividualToUpdate.Individual.IndividualSecondName = txtSecondName.Text.ToString();
IndividualToUpdate.Individual.IndividualLastname = txtLastName.Text.ToString();
IndividualToUpdate.TypeOfRelationID = Convert.ToInt32(cboRelationType.SelectedValue);
Dbconnection.SaveChanges();
////saves all above operations within one transaction
Dbconnection.SaveChanges();
if (CurrentNextOfKin != null)
{
CurrentNextOfKin.Individual.TitleID = Convert.ToInt32(cboIndividualTitle.SelectedValue);
CurrentNextOfKin.Individual.IndividualFirstName = txtFirstName.Text.ToString();
CurrentNextOfKin.Individual.IndividualSecondName = txtSecondName.Text.ToString();
CurrentNextOfKin.Individual.IndividualLastname = txtLastName.Text.ToString();
CurrentNextOfKin.TypeOfRelationID = Convert.ToInt32(cboRelationType.SelectedValue);
}
//commit transaction
dbTran.Commit();
this.Close();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
}
public async Task <ActionResult> BankDetails(TBL_SETTINGS_BANK_DETAILS objval)
{
var db = new DBContext();
using (System.Data.Entity.DbContextTransaction ContextTransaction = db.Database.BeginTransaction())
{
try
{
var checkbankinfo = await db.TBL_SETTINGS_BANK_DETAILS.Where(x => x.SL_NO == objval.SL_NO).FirstOrDefaultAsync();
if (checkbankinfo == null)
{
objval.CREATED_DATE = DateTime.Now;
objval.CREATED_BY = MemberCurrentUser.MEM_ID;
objval.CREATED_BY = 0;
objval.MEM_ID = MemberCurrentUser.MEM_ID;
objval.ISDELETED = 0;
objval.CREATED_BY = MemberCurrentUser.MEM_ID;
db.TBL_SETTINGS_BANK_DETAILS.Add(objval);
await db.SaveChangesAsync();
//return RedirectToAction("Index");
}
else
{
checkbankinfo.MEM_ID = MemberCurrentUser.MEM_ID;
checkbankinfo.BANK = objval.BANK;
checkbankinfo.IFSC = objval.IFSC;
checkbankinfo.MICR_CODE = objval.MICR_CODE;
checkbankinfo.CITY = objval.CITY;
checkbankinfo.BRANCH = objval.BRANCH;
checkbankinfo.CONTACT = objval.CONTACT;
checkbankinfo.STATE = objval.STATE;
checkbankinfo.ADDRESS = objval.ADDRESS;
checkbankinfo.DISTRICT = objval.DISTRICT;
db.Entry(checkbankinfo).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
//return RedirectToAction("Index");
}
ContextTransaction.Commit();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ContextTransaction.Rollback();
Logger.Error("Controller:- SuperBankDetails(Super), method:- BankDetails (POST) Line No:- 220", ex);
return(RedirectToAction("Exception", "ErrorHandler", new { area = "" }));
throw ex;
}
}
}
private void toolStripButton12_Click(object sender, EventArgs e)
{
if (companyContactsBindingSource.Count > 0)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
CompanyContacts CC = (CompanyContacts)companyContactsBindingSource.Current;
Individual CCFromCache = CurrentlySelectedCompany.Individuals.Where(a => a.IndividualID == CC.IndividualID).First();
// return one instance each entity by primary key
var C = Dbconnection.Companies.FirstOrDefault(a => a.CompanyID == CurrentlySelectedCompany.CompanyID);
var I = Dbconnection.Individuals.FirstOrDefault(a => a.IndividualID == CC.IndividualID);
// call Remove method from navigation property for any instance
C.Individuals.Remove(I);
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
CurrentlySelectedCompany.Individuals.Remove(CCFromCache);
this.refreshCompanyContacts();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
}
}
private void btnUpdateCompanyInfo_Click(object sender, EventArgs e)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
Data.Models.Company UpdateCompany = (from a in Dbconnection.Companies
where a.CompanyID == CurrentlySelectedCompany.CompanyID
select a)
.FirstOrDefault <Data.Models.Company>();
UpdateCompany.CompanyName = txtCompanyName.Text;
UpdateCompany.CompanySETANumber = txtSETANumber.Text;
UpdateCompany.CompanySicCode = txtSiCode.Text;
UpdateCompany.CompanySARSLevyRegistrationNumber = txtSARSLevyReg.Text;
Dbconnection.Entry(UpdateCompany).State = EntityState.Modified;
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
}
private void resetAdressDefaults(int AddressID = 0)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
CompanyAddresses CurrentCompanyAddress = ((CompanyAddresses)companyAddressesBindingSource.Current);
Address CurrentAddress = (Address)CurrentlySelectedCompany.Addresses.Where(a => a.AddressID == CurrentCompanyAddress.AddressID).FirstOrDefault();
// Dbconnection.Companies.Attach(CurrentlySelectedCompany);
foreach (Address Add in CurrentlySelectedCompany.Addresses)
{
if (AddressID != Add.AddressID)
{
Add.AddressIsDefault = false;
var AddressToupdate = Dbconnection.Addresses.FirstOrDefault(s => s.AddressID == Add.AddressID);
AddressToupdate.AddressIsDefault = false;
}
}
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
}
public async Task <JsonResult> PostMerchantCouponStockRequisition(TBL_COUPON_TRANSFER_LOGS objReq)
{
initpage();
var db = new DBContext();
using (System.Data.Entity.DbContextTransaction ContextTransaction = db.Database.BeginTransaction())
{
try
{
var getSuper = db.TBL_MASTER_MEMBER.FirstOrDefault(x => x.MEM_ID == CurrentMerchant.MEM_ID);
long SuperId = 0;
long.TryParse(getSuper.INTRODUCER.ToString(), out SuperId);
var GetCouponType = db.TBL_COUPON_MASTER.FirstOrDefault(x => x.couponType == objReq.COUPON_Name);
string GetRefNo = GetUniqueKey(CurrentMerchant.MEM_ID.ToString());
TBL_COUPON_TRANSFER_LOGS objCoupon = new TBL_COUPON_TRANSFER_LOGS()
{
REFERENCE_NO = GetRefNo,
TO_MEMBER = 0,
FROM_MEMBER = CurrentMerchant.MEM_ID,
REQUEST_DATE = objReq.REQUEST_DATE,
REQUEST_TIME = DateTime.Now,
QTY = objReq.QTY,
COUPON_TYPE = GetCouponType.sln,
STATUS = "Pending",
APPROVED_BY = "",
REMARKS = objReq.REMARKS,
COMM_SLAB_ID = 0,
SELL_VALUE_RATE = 0,
GROSS_SELL_VALUE = 0,
NET_SELL_VALUE = 0,
GST_PERCENTAGE = 0,
GST_VALUE = 0,
TDS_PERCENTAGE = 0,
TDS_VALUE = 0,
GST_INPUT = 0,
GST_OUTPUT = 0,
IS_OVERRIDE_SELL_VALUE = false,
MEM_ROLE = 5
};
db.TBL_COUPON_TRANSFER_LOGS.Add(objCoupon);
db.SaveChanges();
ContextTransaction.Commit();
return(Json("Requisition send to admin", JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
ContextTransaction.Rollback();
throw ex;
}
}
}
private void button1_Click(object sender, EventArgs e)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
Student newStudent = new Student()
{
StudentID = 0,
StudentIDNumber = "",
Individual = new Individual()
{
IndividualFirstName = "sdafsadfdsa",
IndividualSecondName = "sdf",
IndividualLastname = "4324"
}
};
Dbconnection.Students.Add(newStudent);
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
}
private void btnUpdateVenueFromForm_Click(object sender, EventArgs e)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
Venue CurrentVenue = (Venue)venueBindingSource.Current;
Venue VenueToUpdate = Dbconnection.Venues.Where(a => a.VenueID == CurrentVenue.VenueID).FirstOrDefault();
VenueToUpdate.VenueName = this.txtVenueName.Text;
VenueToUpdate.VenueMaxCapacity = (int)this.nudAddUpdateVenueCapacity.Value;
Dbconnection.Entry(VenueToUpdate).State = EntityState.Modified;
//CurrentVenue.VenueName = this.txtVenueName.Text;
//CurrentVenue.VenueMaxCapacity = (int)this.nudAddUpdateVenueCapacity.Value;
//Dbconnection.Entry(CurrentVenue).State = System.Data.Entity.EntityState.Modified;
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
this.hideAddEditVenues();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
refreshVenues();
}
private void btnAddDisability_Click(object sender, EventArgs e)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
CurrentStudentDisablity = new StudentDisability()
{
DisabilityID = this.DisablityID,
StudentID = this.StudentID,
StudentDisabilityNotes = this.txtStudentDisablityNotes.Text
};
Dbconnection.StudentDisabilities.Add(CurrentStudentDisablity);
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
Dbconnection.Entry(CurrentStudentDisablity).Reference(a => a.LookupDisability).Load();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
finally{
this.Close();
}
}
};
}
private void btnAddActivity_Click(object sender, EventArgs e)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
int ActvityCategoryID = Convert.ToInt32(cboActivityCategory.SelectedValue);
Activity act = new Activity()
{
ActivityCode = txtActivityCode.Text,
ActivitiyDescription = txtActivityDescription.Text,
ActvityCategoryID = ActvityCategoryID
};
Dbconnection.Activities.Add(act);
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
this.populateAvailableModuleActivities();
this.setAddRemoveControls();
}
public async Task <JsonResult> MemberStatusUpdate(string id, string statusval)
{
var db = new DBContext();
using (System.Data.Entity.DbContextTransaction ContextTransaction = db.Database.BeginTransaction())
{
try
{
long memid = long.Parse(id);
bool memberstatus = false;
if (statusval == "True")
{
memberstatus = false;
}
else
{
memberstatus = true;
}
var memberlist = db.TBL_MASTER_MEMBER.Where(x => x.MEM_ID == memid).FirstOrDefault();
if (statusval == "True")
{
memberlist.ACTIVE_MEMBER = false;
}
else
{
memberlist.ACTIVE_MEMBER = true;
}
memberlist.IS_DELETED = true;
//memberlist.UName = memberlist.UName;
//memberlist.PIN = memberlist.PIN;
//memberlist.User_pwd = memberlist.User_pwd;
//memberlist.BLOCKED_BALANCE = memberlist.BLOCKED_BALANCE;
db.Entry(memberlist).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
ContextTransaction.Commit();
return(Json(new { Result = "true" }));
}
catch (Exception ex)
{
Logger.Error("Controller:- CreateMember(PowerAdmin), method:- MemberStatusUpdate (POST) Line No:- 438", ex);
ContextTransaction.Rollback();
return(Json(new { Result = "false" }));
}
}
}
public async Task <ActionResult> ChangePassword(MerchantChangePasswordModel value)
{
initpage();
var db = new DBContext();
using (System.Data.Entity.DbContextTransaction ContextTransaction = db.Database.BeginTransaction())
{
try
{
long mem_id = CurrentMerchant.MEM_ID;
var changepass = db.TBL_MASTER_MEMBER.Where(x => x.MEM_ID == mem_id).FirstOrDefault();
if (changepass != null)
{
changepass.User_pwd = value.User_pwd;
db.Entry(changepass).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
}
var token = TokenGenerator.GenerateToken();
var PasswordResetObj = new TBL_PASSWORD_RESET
{
ID = token,
EmailID = changepass.EMAIL_ID,
Time = DateTime.Now
};
db.TBL_PASSWORD_RESET.Add(PasswordResetObj);
db.SaveChanges();
//throw new Exception();
ContextTransaction.Commit();
FormsAuthentication.SignOut();
Session["MerchantUserId"] = null;
Session["MerchantUserName"] = null;
Session.Clear();
Session.Remove("MerchantUserId");
Session.Remove("MerchantUserName");
//return RedirectToAction("Message");
return(RedirectToAction("Message", "MerchantLogin", new { area = "Merchant" }));
}
catch (Exception ex)
{
ContextTransaction.Rollback();
Logger.Error("Controller:- DistributorPasswordChange(Super), method:- ChangePassword (POST) Line No:- 124", ex);
return(RedirectToAction("Exception", "ErrorHandler", new { area = "" }));
throw ex;
//return View("Error", new HandleErrorInfo(ex, "APILabel", "CreateMember"));
}
}
}
private void btnRemoveVenue_Click(object sender, EventArgs e)
{
DialogResult Rtn = MessageBox.Show("Are you sure as this will remove all information Associated with this Venue?", "Confirmation", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (Rtn == DialogResult.Yes)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
Venue CurrentVenue = (Venue)venueBindingSource.Current;
Dbconnection.Entry(CurrentVenue).State = System.Data.Entity.EntityState.Deleted;
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
refreshVenues();
}
}
public async Task <JsonResult> MemberStatusUpdate(string id, string statusval)
{
initpage();
var db = new DBContext();
using (System.Data.Entity.DbContextTransaction ContextTransaction = db.Database.BeginTransaction())
{
try
{
long memid = long.Parse(id);
bool memberstatus = false;
if (statusval == "True")
{
memberstatus = false;
}
else
{
memberstatus = true;
}
var memberlist = await db.TBL_MASTER_MEMBER.Where(x => x.MEM_ID == memid).FirstOrDefaultAsync();
if (statusval == "True")
{
memberlist.ACTIVE_MEMBER = false;
}
else
{
memberlist.ACTIVE_MEMBER = true;
}
memberlist.IS_DELETED = true;
db.Entry(memberlist).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
ContextTransaction.Commit();
return(Json(new { Result = "true" }));
}
catch (Exception ex)
{
ContextTransaction.Rollback();
Logger.Error("Controller:- Retailer(Distributor), method:- MemberStatusUpdate (POST) Line No:- 481", ex);
return(Json(new { Result = "false" }));
}
}
}
private void btnUpdateCurriculumCourse_Click(object sender, EventArgs e)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
CurriculumCourse courseObj = (from a in Dbconnection.CurriculumCourses
where a.CurriculumCourseID == this.CurriculumCourseID
select a).FirstOrDefault <CurriculumCourse>();
courseObj.Cost = Convert.ToDecimal(txtCourseCost.Text);
courseObj.Duration = Convert.ToInt32(nudCourseDuration.Value);
courseObj.CurriculumCourseMinimumMaximum.CurriculumCourseMaximum = Convert.ToInt32(nudCourseMaximumAllowed.Value);
courseObj.CurriculumCourseMinimumMaximum.CurriculumCourseMinimum = Convert.ToInt32(nudCourseMinimumAllowed.Value);
courseObj.CurricullumCourseCode.CurricullumCourseCodeValue = txtCourseCourseCode.Text;
courseObj.CostCode = txtCurrentCostCode.Text;
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
}
private void btnAddVenueFromForm_Click(object sender, EventArgs e)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
Venue newVenue = new Venue()
{
VenueName = this.txtVenueName.Text,
VenueMaxCapacity = 0
};
Dbconnection.Venues.Add(newVenue);
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
this.hideAddEditVenues();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
refreshVenues();
}
private void btnRemoveStudentClientInfo_Click(object sender, EventArgs e)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
CompanyContacts CC = (CompanyContacts)companyContactsBindingSource.Current;
Individual CCFromCache = CurrentlySelectedCompany.Individuals.Where(a => a.IndividualID == CC.IndividualID).First();
CompanyContactDetails CD = (CompanyContactDetails)companyContactsDetailsBindingSource.Current;
ContactDetail CDFromCache = CCFromCache.ContactDetails.Where(a => a.ContactDetailID == CD.ContactDetailID).First();
Dbconnection.ContactDetails.Attach(CDFromCache);
Dbconnection.ContactDetails.Remove(CDFromCache);
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
CCFromCache.ContactDetails.Remove(CDFromCache);
this.refreshCompanyContactsDetails();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
}
private void btnAddUpdateStudentDisablity_Click(object sender, EventArgs e)
{
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
if (CurrentStudentDisablity != null)
{
Dbconnection.StudentDisabilities.Attach(CurrentStudentDisablity);
CurrentStudentDisablity.StudentDisabilityNotes = this.txtStudentDisablityNotes.Text;
Dbconnection.Entry(CurrentStudentDisablity).State = EntityState.Modified;
}
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
this.Close();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
}
private void btnUpdateCurriculumCourseEnrollmentCost_Click(object sender, EventArgs e)
{
CurriculumCourseEnrollment CCE = (CurriculumCourseEnrollment)curriculumCourseEnrollmentsMainCoursesBindingSource.Current;
using (var Dbconnection = new MCDEntities())
{
using (System.Data.Entity.DbContextTransaction dbTran = Dbconnection.Database.BeginTransaction())
{
try
{
//CRUD Operations
Dbconnection.CurriculumCourseEnrollments.Attach(CCE);
CCE.CourseCost = Convert.ToInt32(txtUpdateCurriulumCourseEnrollemntCost.Text);
Dbconnection.Entry(CCE).State = EntityState.Modified;
////saves all above operations within one transaction
Dbconnection.SaveChanges();
//commit transaction
dbTran.Commit();
Close();
}
catch (Exception ex)
{
if (ex is DbEntityValidationException)
{
foreach (DbEntityValidationResult entityErr in ((DbEntityValidationException)ex).EntityValidationErrors)
{
foreach (DbValidationError error in entityErr.ValidationErrors)
{
MessageBox.Show(error.ErrorMessage, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
MessageBox.Show(ex.Message, "Error Message", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//Rollback transaction if exception occurs
dbTran.Rollback();
}
}
};
}
protected Collection CollectionLog(Collection collection, CollectionStatus status)
{
using (System.Data.Entity.DbContextTransaction dbTran = upsertContext.Database.BeginTransaction())
{
try
{
Collection one = upsertContext.Collections.Find(collection.ID);
one.status = status;
upsertContext.SaveChanges();
dbTran.Commit();
}
catch (Exception e)
{
log.Error(e);
dbTran.Rollback();
}
dbTran.Dispose();
}
return(collection);
}
protected void ChannelStatus(Channel channel, ActionStatus status)
{
using (System.Data.Entity.DbContextTransaction dbTran = upsertContext.Database.BeginTransaction())
{
try
{
Channel c = upsertContext.Channels.Find(channel.ID);
c.action = status;
upsertContext.Entry(c).State = EntityState.Modified;
upsertContext.SaveChanges();
dbTran.Commit();
}
catch (Exception e)
{
log.Error(e);
dbTran.Rollback();
}
dbTran.Dispose();
}
}
public async Task <JsonResult> DeactiveOperator(string Id)
{
try
{
var db = new DBContext();
using (System.Data.Entity.DbContextTransaction ContextTransaction = db.Database.BeginTransaction())
{
long MemID = long.Parse(Id);
var getdocinfo = await db.TBL_SETTINGS_SERVICES_MASTER.Where(x => x.SLN == MemID).FirstOrDefaultAsync();
if (getdocinfo != null)
{
if (getdocinfo.ACTIVESTATUS == true)
{
getdocinfo.ACTIVESTATUS = false;
}
else
{
getdocinfo.ACTIVESTATUS = true;
}
getdocinfo.UPDATED_ON = DateTime.Now;
db.Entry(getdocinfo).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
ContextTransaction.Commit();
return(Json(new { Result = "true" }));
}
else
{
ContextTransaction.Rollback();
return(Json(new { Result = "false" }));
}
}
//string decrptMemId = Decrypt.DecryptMe(Id);
}
catch (Exception ex)
{
Logger.Error("Controller:- PowerAdminServicesMaster, method:- DeactiveOperator(POST) Line No:- 225", ex);
throw;
}
}
public async Task <ActionResult> Index(ManageUserProfileDetails objval)
{
initpage();////
var db = new DBContext();
using (System.Data.Entity.DbContextTransaction ContextTransaction = db.Database.BeginTransaction())
{
try
{
long mem_id = MemberCurrentUser.MEM_ID;
var changepass = db.TBL_MASTER_MEMBER.Where(x => x.MEM_ID == mem_id).FirstOrDefault();
if (changepass != null)
{
changepass.UName = objval.UName;
changepass.COMPANY = objval.COMPANY;
changepass.MEMBER_MOBILE = objval.MEMBER_MOBILE;
changepass.MEMBER_NAME = objval.MEMBER_NAME;
changepass.ADDRESS = objval.ADDRESS;
changepass.CITY = objval.CITY;
changepass.PIN = objval.PIN;
db.Entry(changepass).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
}
//throw new Exception();
ContextTransaction.Commit();
ViewBag.Message = "Profile Updated Successfully...";
return(View());
}
catch (Exception ex)
{
ContextTransaction.Rollback();
Logger.Error("Controller:- MemberChangePassword(Admin), method:- ChangePassword (POST) Line No:- 271", ex);
return(RedirectToAction("Exception", "ErrorHandler", new { area = "" }));
throw ex;
//return View("Error", new HandleErrorInfo(ex, "APILabel", "CreateMember"));
}
}
//return View();
}
public void JobLog(Channel c, BatchStatus batchStatus, string message)
{
using (System.Data.Entity.DbContextTransaction dbTran = upsertContext.Database.BeginTransaction())
{
try
{
Batch batch = new Batch {
name = c.name, bound = c.bound, status = batchStatus, message = message
};
upsertContext.Batches.Add(batch);
upsertContext.SaveChanges();
dbTran.Commit();
}
catch (Exception e)
{
log.Error(e);
dbTran.Rollback();
}
dbTran.Dispose();
}
}
protected void CollectionLog(Channel channel, string name, string ftpname, CollectionStatus status)
{
using (System.Data.Entity.DbContextTransaction dbTran = upsertContext.Database.BeginTransaction())
{
try
{
Collection collection = new Collection {
channelId = channel.ID, name = name, ftpname = ftpname, status = status
};
upsertContext.Collections.Add(collection);
upsertContext.SaveChanges();
dbTran.Commit();
}
catch (Exception e)
{
log.Error(e);
dbTran.Rollback();
}
dbTran.Dispose();
}
}
public async Task <JsonResult> DeactiveOperator(string Id)
{
try
{
var db = new DBContext();
using (System.Data.Entity.DbContextTransaction ContextTransaction = db.Database.BeginTransaction())
{
long MemID = long.Parse(Id);
var getdocinfo = await db.TBL_WHITE_LEVEL_COMMISSION_SLAB.Where(x => x.SLN == MemID).FirstOrDefaultAsync();
if (getdocinfo != null)
{
if (getdocinfo.SLAB_STATUS == false)
{
getdocinfo.SLAB_STATUS = true;
}
else
{
getdocinfo.SLAB_STATUS = false;
}
db.Entry(getdocinfo).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
ContextTransaction.Commit();
return(Json(new { Result = "true" }));
}
else
{
ContextTransaction.Rollback();
return(Json(new { Result = "false" }));
}
}
//string decrptMemId = Decrypt.DecryptMe(Id);
}
catch (Exception ex)
{
Logger.Error("Controller:- PowerAdminCommissionSlab(PowerAdmin), method:- AddCommissionSlab (GET) Line No:- 678", ex);
throw;
}
}
public async Task <ActionResult> ChangePassword(MemberChangePasswordModel value)
{
initpage();////
var db = new DBContext();
using (System.Data.Entity.DbContextTransaction ContextTransaction = db.Database.BeginTransaction())
{
try
{
long mem_id = MemberCurrentUser.MEM_ID;
var changepass = db.TBL_MASTER_MEMBER.Where(x => x.MEM_ID == mem_id).FirstOrDefault();
if (changepass != null)
{
changepass.User_pwd = value.User_pwd;
db.Entry(changepass).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
}
//throw new Exception();
ContextTransaction.Commit();
FormsAuthentication.SignOut();
Session["SuperDistributorId"] = null;
Session["SuperDistributorUserName"] = null;
Session.Clear();
Session.Remove("SuperDistributorId");
Session.Remove("SuperDistributorUserName");
//return RedirectToAction("Message");
return(RedirectToAction("Message", "SuperLogin", new { area = "Super" }));
}
catch (Exception ex)
{
ContextTransaction.Rollback();
Logger.Error("Controller:- SuperChangePassword(Super), method:- ChangePassword (POST) Line No:- 127", ex);
return(RedirectToAction("Exception", "ErrorHandler", new { area = "" }));
throw ex;
//return View("Error", new HandleErrorInfo(ex, "APILabel", "CreateMember"));
}
}
}
public bool updateAutorizaRem(int consec, string autoriza, string autorizo, DateTime fecha, string comentario)
{
using (var context = new SEMP2013_Context())
{
using (System.Data.Entity.DbContextTransaction dbTran = context.Database.BeginTransaction())
{
try
{
var remision = context.remisiones.
Where(p => p.consec == consec).FirstOrDefault();
if (remision == null)
{
return(false);
}
remision.audita = autoriza;
remision.auditado = autorizo.Substring(0, 3);
remision.fechaAuditado = fecha;
remision.comentarioAuditado = comentario;
context.remisiones.Attach(remision);
context.Entry(remision).State = System.Data.Entity.EntityState.Modified;
context.SaveChanges();
dbTran.Commit();
return(true);
}
catch (Exception ex)
{
//Rollback transaction if exception occurs
dbTran.Rollback();
return(false);
}
}
}
}
public void ActivateDeactivate(long[] id, string LoginID, string ActivateDeactivate)
{
using (System.Data.Entity.DbContextTransaction dbTran = _db.Database.BeginTransaction())
{
try
{
_db.VSEC_USER_MST
.Where(x => id.Contains(x.UserMstID))
.ToList()
.ForEach(a =>
{
a.Status = ActivateDeactivate == "Activate" ? "A" : "D";
a.MC_Status = ActivateDeactivate == "Activate" ? "A" : "D";
a.LastUpDtBy = LoginID;
a.LastUpDtOn = DateTime.Now;
});
_db.SaveChanges();
_db.VSEC_LOGIN_MST
.Where(x => id.Contains((long)x.UserMstID))
.ToList()
.ForEach(a =>
{
a.ActiveStatus = ActivateDeactivate == "Activate" ? "Y" : "N";
a.UpdatedBy = LoginID;
a.UpdatedOn = DateTime.Now;
});
_db.SaveChanges();
dbTran.Commit();
}
catch (System.Data.Entity.Validation.DbEntityValidationException e)
{
dbTran.Rollback();
}
}
}
public async Task <JsonResult> DeactivateBankDetails(string id)
{
initpage();////
var db = new DBContext();
using (System.Data.Entity.DbContextTransaction ContextTransaction = db.Database.BeginTransaction())
{
try
{
long idval = long.Parse(id);
var bankdeactive = await db.TBL_SETTINGS_BANK_DETAILS.Where(x => x.SL_NO == idval).FirstOrDefaultAsync();
bankdeactive.DELETED_DATE = System.DateTime.Now;
if (bankdeactive.ISDELETED == 1)
{
bankdeactive.ISDELETED = 0;
bankdeactive.DELETED_BY = 0;
}
else
{
bankdeactive.ISDELETED = 1;
bankdeactive.DELETED_BY = 0;
}
db.Entry(bankdeactive).State = System.Data.Entity.EntityState.Modified;
await db.SaveChangesAsync();
ContextTransaction.Commit();
return(Json(new { Result = "true" }));
}
catch (Exception ex)
{
Logger.Error("Controller:- SuperBankDetails(Super), method:- DeactivateBankDetails (POST) Line No:- 250", ex);
ContextTransaction.Rollback();
return(Json(new { Result = "false" }));
}
}
}
/// <summary>
/// Copies the fileId to this Folder.
/// </summary>
/// <param name="destination"></param>
/// <param name="fileId"></param>
/// <param name="destinationName"></param>
/// <param name="user"></param>
/// <param name="context"></param>
/// <param name="dbcxtransaction"></param>
public static void CopyFileHere(this Folder destination, Guid fileId, string destinationName, Principal user, OnlineFilesEntities context = null, DbContextTransaction dbcxtransaction = null)
{
bool createdContext = false;
bool createdTransaction = false;
bool didRollback = false;
if (context == null)
{
createdContext = true;
context = new OnlineFilesEntities();
}
if (dbcxtransaction == null)
{
dbcxtransaction = context.Database.BeginTransaction();
createdTransaction = true;
}
try
{
var destSecurity = context.FolderSecurities.Where(d => d.fk_FolderId == destination.pk_FolderId);
//Can the user create files at the destination location?
if (destSecurity.Any(d => d.canCreateFiles && user.UserProfile.mySecurityGroups.Contains(d.SecurityObjectId)))
{
var file = context.Files
.Include(x => x.FileSecurities)
.Include(x => x.FileDatas)
.FirstOrDefault(d => d.pk_FileId == fileId);
//Can the user Read the file to be copied?
if (file.FileSecurities.Any(f => user.UserProfile.mySecurityGroups.Contains(f.SecurityObjectId) && f.canRead))
{
File newFile = File.Create(destination.pk_FolderId, file.Name, user.UserProfile, true);
context.SaveChanges();
//Copy the file data
using (Stream s = file.OpenReadStream(user))
using (Stream d = newFile.OpenWriteStream(user))
s.CopyTo(d);
//Copy the file Security
foreach (FileSecurity security in file.FileSecurities)
{
FileSecurity nsec = context.FileSecurities.FirstOrDefault(d => d.fk_FileId == newFile.pk_FileId && d.SecurityObjectId == security.SecurityObjectId);
if (nsec == null)
{
nsec = new FileSecurity()
{
canRead = security.canRead,
canWrite = security.canWrite,
CanDelete = security.CanDelete,
fk_FileId = newFile.pk_FileId,
SecurityObjectId = security.SecurityObjectId
};
context.FileSecurities.Add(nsec);
}
else
{
nsec.canRead = nsec.canRead || security.canRead;
nsec.CanDelete = nsec.CanDelete || security.CanDelete;
nsec.canWrite = nsec.canWrite || security.canWrite;
}
}
context.SaveChanges();
}
else
{
throw new SecurityException("Not Authorized.");
}
}
else
{
throw new SecurityException("Not Authorized.");
}
}
catch (Exception)
{
//If we got an error and we created the transaction, roll it back.
if (createdTransaction)
{
dbcxtransaction.Rollback();
didRollback = true;
}
throw;
}
finally
{
if (createdTransaction)
{
//If we didn't roll back the transaction, commit it.
if (!didRollback)
dbcxtransaction.Commit();
dbcxtransaction.Dispose();
}
if (createdContext)
context.Dispose();
}
}
/// <summary>
/// Will set the permissions for the targetUser, use recursive if you want it to propagate to child file and folders.
/// context & dbcxtransaction should be null.
/// </summary>
/// <param name="FolderId"></param>
/// <param name="user"></param>
/// <param name="targetUser"></param>
/// <param name="canListObjects"></param>
/// <param name="canCreateFiles"></param>
/// <param name="canCreateFolders"></param>
/// <param name="canDelete"></param>
/// <param name="canChangePermissions"></param>
/// <param name="recursive"></param>
/// <param name="context"></param>
/// <param name="dbcxtransaction"></param>
public static void SetPermissions(Guid FolderId, Principal user, Principal targetUser, bool canListObjects, bool canCreateFiles, bool canCreateFolders, bool canDelete, bool canChangePermissions, bool recursive = false, OnlineFilesEntities context = null, DbContextTransaction dbcxtransaction = null)
{
bool createdContext = false;
bool createdTransaction = false;
bool didRollback = false;
if (context == null)
{
createdContext = true;
context = new OnlineFilesEntities();
}
if (dbcxtransaction == null)
{
dbcxtransaction = context.Database.BeginTransaction();
createdTransaction = true;
}
try
{
Folder target = context.Folders
.Include(d => d.FolderSecurities)
.FirstOrDefault(d => d.pk_FolderId == FolderId);
//Can the user Change Permissions
if (target.FolderSecurities.Any(d => d.canChangePermissions && user.UserProfile.mySecurityGroups.Contains(d.SecurityObjectId)))
{
var secRecord = target.FolderSecurities.FirstOrDefault(d => d.SecurityObjectId == targetUser.UserProfile.SecurityObjectId);
if (secRecord == null)
{
secRecord = new FolderSecurity()
{
SecurityObjectId = targetUser.UserProfile.SecurityObjectId,
canChangePermissions = canChangePermissions,
canListObjects = canListObjects,
canCreateFolders = canCreateFolders,
canCreateFiles = canCreateFiles,
canDelete = canDelete,
fk_FolderId = target.pk_FolderId
};
target.FolderSecurities.Add(secRecord);
}
else
{
secRecord.canListObjects = canListObjects;
secRecord.canChangePermissions = canChangePermissions;
secRecord.canCreateFiles = canCreateFiles;
secRecord.canCreateFolders = canCreateFolders;
secRecord.canDelete = canDelete;
}
foreach (File source in context.Files.Where(d => d.fk_FolderId == target.pk_FolderId))
File.SetPermissions(source.pk_FileId, user, targetUser, canListObjects, canCreateFiles, canDelete, context, dbcxtransaction);
context.SaveChanges();
if (recursive)
foreach (Folder folder in context.Folders.Where(d => d.fk_ParentFolderId == target.pk_FolderId))
SetPermissions(folder.pk_FolderId, user, targetUser, canListObjects, canCreateFiles, canCreateFolders, canDelete, canChangePermissions, recursive, context, dbcxtransaction);
}
else
{
throw new SecurityException("Not Authorized.");
}
}
catch (Exception)
{
if (createdTransaction)
{
didRollback = true;
dbcxtransaction.Rollback();
}
throw;
}
finally
{
if (createdTransaction)
{
if (!didRollback)
dbcxtransaction.Commit();
dbcxtransaction.Dispose();
}
if (createdContext)
context.Dispose();
}
}
/// <summary>
/// Copies the folderId to this Folder
/// </summary>
/// <param name="destination"></param>
/// <param name="folderId"></param>
/// <param name="destinationName"></param>
/// <param name="user"></param>
/// <param name="context"></param>
/// <param name="recursive"></param>
/// <param name="dbcxtransaction"></param>
public static void CopyFolderHere(this Folder destination, Guid folderId, string destinationName, Principal user, OnlineFilesEntities context = null, bool recursive = true, DbContextTransaction dbcxtransaction = null)
{
bool createdContext = false;
bool createdTransaction = false;
bool didRollback = false;
if (context == null)
{
createdContext = true;
context = new OnlineFilesEntities();
}
if (dbcxtransaction == null)
{
dbcxtransaction = context.Database.BeginTransaction();
createdTransaction = true;
}
try
{
var destSecurity = context.FolderSecurities.Where(d => d.fk_FolderId == destination.pk_FolderId);
//Can the user create folders at the destination location?
if (destSecurity.Any(d => d.canCreateFolders && user.UserProfile.mySecurityGroups.Contains(d.SecurityObjectId)))
{
Folder folderToMove = context.Folders.Include(d => d.FolderSecurities).FirstOrDefault(d => d.pk_FolderId == folderId);
if (folderToMove == null)
throw new Exception("Cannot move a non existant folder");
Folder parentToFolderToMove = context.Folders.Include(x => x.FolderSecurities).FirstOrDefault(d => d.pk_FolderId == folderToMove.fk_ParentFolderId);
if (parentToFolderToMove == null)
throw new Exception("No parent to folder being moved.");
//Does the user have read permission in the folder the item is comming from?
if (parentToFolderToMove.FolderSecurities.Any(d => user.UserProfile.mySecurityGroups.Contains(d.SecurityObjectId) && d.canListObjects))
{
Folder newFolder = Folder.Create(destinationName, destination.pk_FolderId, user.UserProfile, true);
context.SaveChanges();
if (recursive)
{
//Get all the files that are in the folder being copied.
var files = context.Files.Where(d => d.fk_FolderId == folderToMove.pk_FolderId);
foreach (File file in files)
newFolder.CopyFileHere(file.pk_FileId, file.Name, user, context, dbcxtransaction);
//Get all the folders inside the folder we are moving.
var folders = context.Folders.Where(d => d.fk_ParentFolderId == folderToMove.pk_FolderId);
//Copy the folders to the new location
foreach (var folder in folders)
newFolder.CopyFolderHere(folder.pk_FolderId, folder.Name, user, context, recursive, dbcxtransaction);
}
context.SaveChanges();
}
else
{
throw new SecurityException("Not Authorized.");
}
}
else
{
throw new SecurityException("Not Authorized.");
}
}
catch (Exception)
{
if (createdTransaction)
{
didRollback = true;
dbcxtransaction.Rollback();
}
throw;
}
finally
{
if (createdTransaction)
{
if (!didRollback)
dbcxtransaction.Commit();
dbcxtransaction.Dispose();
}
if (createdContext)
context.Dispose();
}
}
public void Calling_Rollback_twice_on_a_DbContextTransaction_calls_Rollback_twice_on_underlying_EntityTransaction()
{
var mockEntityTransaction = new Mock<EntityTransaction>();
var mockEntityConnection = new Mock<EntityConnection>();
mockEntityConnection.SetupGet(m => m.State).Returns(ConnectionState.Open);
mockEntityConnection.Setup(m => m.BeginTransaction()).Returns(mockEntityTransaction.Object);
var dbContextTransaction = new DbContextTransaction(mockEntityConnection.Object);
dbContextTransaction.Rollback();
dbContextTransaction.Rollback();
mockEntityTransaction.Verify(m => m.Rollback(), Times.Exactly(2));
}
/// <summary>
/// Set the permission on a file for the target User.
/// </summary>
/// <param name="fileId"></param>
/// <param name="user"></param>
/// <param name="targetUser"></param>
/// <param name="canRead"></param>
/// <param name="canWrite"></param>
/// <param name="canDelete"></param>
/// <param name="context"></param>
/// <param name="dbcxtransaction"></param>
public static void SetPermissions(Guid fileId, Principal user, Principal targetUser, bool canRead, bool canWrite, bool canDelete, OnlineFilesEntities context = null, DbContextTransaction dbcxtransaction = null)
{
bool createdContext = false;
bool createdTransaction = false;
bool didRollback = false;
if (context == null)
{
createdContext = true;
context = new OnlineFilesEntities();
}
if (dbcxtransaction == null)
{
dbcxtransaction = context.Database.BeginTransaction();
createdTransaction = true;
}
try
{
File targetfile = context.Files
.Include(d => d.FileSecurities)
.FirstOrDefault(d => d.pk_FileId == fileId);
if (targetfile == null)
throw new Exception("File does not exist.");
Folder target = context.Folders.Include(d => d.FolderSecurities).FirstOrDefault(d => d.pk_FolderId == targetfile.fk_FolderId);
if (target == null)
throw new Exception("Parent Folder does not exist.");
//Can the user Change Permissions
if (target.FolderSecurities.Any(d => d.canChangePermissions && user.UserProfile.mySecurityGroups.Contains(d.SecurityObjectId)))
{
var secRecord = targetfile.FileSecurities.FirstOrDefault(d => d.SecurityObjectId == targetUser.UserProfile.SecurityObjectId);
if (secRecord == null)
{
secRecord = new FileSecurity
{
fk_FileId = targetfile.pk_FileId,
CanDelete = canDelete,
canRead = canRead,
canWrite = canWrite,
SecurityObjectId = targetUser.UserProfile.SecurityObjectId
};
targetfile.FileSecurities.Add(secRecord);
}
else
{
secRecord.canRead = canRead;
secRecord.CanDelete = canDelete;
secRecord.canWrite = canWrite;
}
context.SaveChanges();
}
else
{
throw new SecurityException("Not Authorized.");
}
}
catch (Exception)
{
if (!createdTransaction)
throw;
didRollback = true;
dbcxtransaction.Rollback();
throw;
}
finally
{
if (createdTransaction)
{
if (!didRollback)
dbcxtransaction.Commit();
dbcxtransaction.Dispose();
}
if (createdContext)
context.Dispose();
}
}
public void Calling_Rollback_on_an_already_disposed_DbContextTransaction_still_calls_Rollback_on_underlying_EntityTransaction()
{
var mockEntityTransaction = new Mock<EntityTransaction>();
var mockEntityConnection = new Mock<EntityConnection>();
mockEntityConnection.SetupGet(m => m.State).Returns(ConnectionState.Open);
mockEntityConnection.Setup(m => m.BeginTransaction()).Returns(mockEntityTransaction.Object);
var dbContextTransaction = new DbContextTransaction(mockEntityConnection.Object);
dbContextTransaction.Dispose();
dbContextTransaction.Rollback();
mockEntityTransaction.Verify(m => m.Rollback(), Times.Once());
}
