public CustomerDTO UpdateCustomerinDB(CustomerDTO customerDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapCustomerAsInput(customerDTO))
{
// 2- Select Customer to be updated
CustomerBusiness customerBusiness = new CustomerBusiness();
CustomerList customerList = customerBusiness.SelectRows(Mapper._Customer.Id, null, null, null, null);
if (customerList != null && customerList.Count > 0)
{
customerList[0].code = Mapper._Customer.code;
customerList[0].name = Mapper._Customer.name;
customerList[0].nameAr = Mapper._Customer.nameAr;
customerList[0].address = Mapper._Customer.address;
customerList[0].phone = Mapper._Customer.phone;
customerList[0].email = Mapper._Customer.email;
customerList[0].workFieldId = Mapper._Customer.workFieldId;
// 3- Update Customer Data by Input Values
customerBusiness = new CustomerBusiness();
if (customerBusiness.UpdateRow(dbTransaction, customerList[0]) > 0)
{
dbTransaction.Commit();
}
else
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
else
{
dbTransaction.Rollback();
throw new Exception("Customer Id Not Found in DB");
}
}
else
{
throw new ArgumentNullException("customerDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw;
}
}
return(customerDTO);
}
public bool DeleteGroupfromDB(int id)
{
bool result = default(bool);
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Select User From DB by ID
GroupBusiness groupBusiness = new GroupBusiness();
GroupList groupList = groupBusiness.SelectRows(id, null);
if (groupList != null && groupList.Count > 0)
{
// 2- Select Group Functions From DB by Group ID
GroupFunctionBusiness _GroupFunctionBusiness = new GroupFunctionBusiness();
GroupFunctionList groupFunctionList = _GroupFunctionBusiness.SelectRows(null, null, id);
if (groupFunctionList != null && groupFunctionList.Count > 0)
{
// 3- Delete Group Functions first (we must remove children first because of DB relation)
foreach (GroupFunction groupFunction in groupFunctionList)
{
_GroupFunctionBusiness = new GroupFunctionBusiness();
_GroupFunctionBusiness.DeleteRow(dbTransaction, groupFunction);
}
}
// 4- Then Delete The Group itself
groupBusiness = new GroupBusiness();
if (groupBusiness.DeleteRow(dbTransaction, groupList[0]) > 0)
{
dbTransaction.Commit();
result = true;
}
else
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
else
{
dbTransaction.Rollback();
throw new Exception("Group Id Not Found in DB");
}
}
catch (Exception)
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
return(result);
}
public bool DeleteUserfromDB(int id)
{
bool result = default(bool);
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Select User From DB by ID
UserBusiness userBusiness = new UserBusiness();
UserList userList = userBusiness.SelectRows(id, null, null, null);
if (userList != null && userList.Count > 0)
{
// 2- Select User Groups From DB by User ID
UserGroupBusiness userGroupBusiness = new UserGroupBusiness();
UserGroupList userGroupList = userGroupBusiness.SelectRows(null, id, null);
if (userGroupList != null && userGroupList.Count > 0)
{
// 3- Delete User Groups first (we must remove children first because of DB relation)
foreach (UserGroup userGroup in userGroupList)
{
userGroupBusiness = new UserGroupBusiness();
userGroupBusiness.DeleteRow(dbTransaction, userGroup);
}
}
// 4- Then Delete The User itself
userBusiness = new UserBusiness();
if (userBusiness.DeleteRow(dbTransaction, userList[0]) > 0)
{
dbTransaction.Commit();
result = true;
}
else
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
else
{
dbTransaction.Rollback();
throw new Exception("User Id Not Found in DB");
}
}
catch (Exception)
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
return(result);
}
public WorkFieldDTO UpdateWorkFieldInDB(WorkFieldDTO workFieldDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapWorkFieldAsInput(workFieldDTO))
{
// 2- Select WorkField to be updated
WorkFieldBusiness workFieldBusiness = new WorkFieldBusiness();
WorkFieldList workFieldList = workFieldBusiness.SelectRows(Mapper._WorkField.Id, null, null);
if (workFieldList != null && workFieldList.Count > 0)
{
workFieldList[0].Id = Mapper._WorkField.Id;
workFieldList[0].name = Mapper._WorkField.name;
workFieldList[0].nameAr = Mapper._WorkField.nameAr;
// 3- Update WorkField Data by Input Values
workFieldBusiness = new WorkFieldBusiness();
if (workFieldBusiness.UpdateRow(dbTransaction, workFieldList[0]) > 0)
{
dbTransaction.Commit();
}
else
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
else
{
dbTransaction.Rollback();
throw new Exception("WorkField Id Not Found in DB");
}
}
else
{
throw new ArgumentNullException("workFieldDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw;
}
}
return(workFieldDTO);
}
public RejectReasonDTO UpdateRejectReasonInDB(RejectReasonDTO rejectReasonDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapRejectReasonAsInput(rejectReasonDTO))
{
// 2- Select RejectReason to be updated
RejectReasonBusiness rejectReasonBusiness = new RejectReasonBusiness();
RejectReasonList rejectReasonList = rejectReasonBusiness.SelectRows(Mapper._WorkField.Id, null, null);
if (rejectReasonList != null && rejectReasonList.Count > 0)
{
rejectReasonList[0].Id = Mapper._RejectReason.Id;
rejectReasonList[0].name = Mapper._RejectReason.name;
rejectReasonList[0].nameAr = Mapper._RejectReason.nameAr;
// 3- Update RejectReason Data by Input Values
rejectReasonBusiness = new RejectReasonBusiness();
if (rejectReasonBusiness.UpdateRow(dbTransaction, rejectReasonList[0]) > 0)
{
dbTransaction.Commit();
}
else
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
else
{
dbTransaction.Rollback();
throw new Exception("RejectReason Id Not Found in DB");
}
}
else
{
throw new ArgumentNullException("rejectReasonDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw;
}
}
return(rejectReasonDTO);
}
public RejectReasonDTO AddRejectReasonToDB(RejectReasonDTO rejectReasonDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapRejectReasonAsInput(rejectReasonDTO))
{
////User user = Mapper._User;
////List<UserGroup> userGroups = Mapper._UserGroupListInput;
//Mapper._User.createDate = DateTime.Now;
// 2- Insert RejectReason in DB
RejectReasonBusiness rejectReasonBusiness = new RejectReasonBusiness();
if (rejectReasonBusiness.InsertRow(dbTransaction, Mapper._RejectReason) > 0)
{
dbTransaction.Commit();
rejectReasonDTO.Id = Mapper._RejectReason.Id;
}
else
{
dbTransaction.Rollback();
throw new DataException("DataBase Operation Failure");
}
}
else
{
throw new ArgumentNullException("rejectReasonDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw;
}
}
return(rejectReasonDTO);
}
//public ICollection<CustomerDTO> GetAllCustomersfromDB()
//{
// ICollection<CustomerDTO> outputList = default(ICollection<CustomerDTO>);
// try
// {
// // 1- Select All Customers From DB
// CustomerBusiness _CustomerBusiness = new CustomerBusiness();
// CustomerList _CustomerList = _CustomerBusiness.SelectRows(null, null, null, null, null);
// if (_CustomerList != null && _CustomerList.Count > 0)
// //outputList = Mapper.MapCustimerAsOutput();
// {
// // 2- Prepare Mapping Objects (Fill Values from DB)
// Mapper._CustomerList = fillCustomerList(); //default(List<Customer>);
// //Mapper._UserList = _UserList;
// //Mapper._UserGroupList = new List<UserGroup>(); //default(List<UserGroup>);
// // Mapper._GroupFunctionList = fillGroupFunctionList(); //default(List<GroupFunction>);
// //UserGroupBusiness _UserGroupBusiness = new UserGroupBusiness();
// //UserGroupList _UserGroupList = default(UserGroupList);
// foreach (Customer customer in _CustomerList)
// {
// }
// // 3- Perform Mapping to Output
// outputList = Mapper.MapCustomersAsOutput();
// }
// }
// catch (Exception ex)
// {
// // Log Exception Here
// throw; //new Exception(ex.Message);
// }
// return outputList;
//}
public CustomerDTO AddCustomerToDB(CustomerDTO cutomerDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapCustomerAsInput(cutomerDTO))
{
////User user = Mapper._User;
////List<UserGroup> userGroups = Mapper._UserGroupListInput;
//Mapper._User.createDate = DateTime.Now;
// 2- Insert Customer in DB
CustomerBusiness customerBusiness = new CustomerBusiness();
if (customerBusiness.InsertRow(dbTransaction, Mapper._Customer) > 0)
{
dbTransaction.Commit();
cutomerDTO.Id = Mapper._Customer.Id;
}
else
{
dbTransaction.Rollback();
throw new DataException("DataBase Operation Failure");
}
}
else
{
throw new ArgumentNullException("customerDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw;
}
}
return(cutomerDTO);
}
public bool DeleteRejectReasonFromDB(int id)
{
bool result = default(bool);
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Select RejectReason From DB by ID
RejectReasonBusiness rejectReasonBusiness = new RejectReasonBusiness();
RejectReasonList rejectReasonList = rejectReasonBusiness.SelectRows(id, null, null);
if (rejectReasonList != null && rejectReasonList.Count > 0)
{
foreach (RejectReason rejectReason in rejectReasonList)
{
rejectReasonBusiness = new RejectReasonBusiness();
rejectReasonBusiness.DeleteRow(dbTransaction, rejectReason);
}
dbTransaction.Commit();
result = true;
}
else
{
dbTransaction.Rollback();
throw new Exception("RejectReason Id Not Found in DB");
}
}
catch (Exception)
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
return(result);
}
public bool DeleteCustomerFromDB(int id)
{
bool result = default(bool);
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Select Customer From DB by ID
CustomerBusiness customerBusiness = new CustomerBusiness();
CustomerList customerList = customerBusiness.SelectRows(id, null, null, null, null);
if (customerList != null && customerList.Count > 0)
{
foreach (Customer customer in customerList)
{
customerBusiness = new CustomerBusiness();
customerBusiness.DeleteRow(dbTransaction, customer);
}
dbTransaction.Commit();
result = true;
}
else
{
dbTransaction.Rollback();
throw new Exception("Customer Id Not Found in DB");
}
}
catch (Exception)
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
return(result);
}
public bool DeleteWorkFieldFromDB(int id)
{
bool result = default(bool);
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Select WorkField From DB by ID
WorkFieldBusiness workFieldBusiness = new WorkFieldBusiness();
WorkFieldList workFieldList = workFieldBusiness.SelectRows(id, null, null);
if (workFieldList != null && workFieldList.Count > 0)
{
foreach (WorkField workField in workFieldList)
{
workFieldBusiness = new WorkFieldBusiness();
workFieldBusiness.DeleteRow(dbTransaction, workField);
}
dbTransaction.Commit();
result = true;
}
else
{
dbTransaction.Rollback();
throw new Exception("WorkField Id Not Found in DB");
}
}
catch (Exception)
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
return(result);
}
WorkFieldDTO IWorkFieldDAL.AddWorkFieldToDB(WorkFieldDTO workFieldDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapWorkFieldAsInput(workFieldDTO))
{
// 2- Insert WorkField in DB
WorkFieldBusiness workFieldBusiness = new WorkFieldBusiness();
if (workFieldBusiness.InsertRow(dbTransaction, Mapper._WorkField) > 0)
{
dbTransaction.Commit();
workFieldDTO.Id = Mapper._WorkField.Id;
}
else
{
dbTransaction.Rollback();
throw new DataException("DataBase Operation Failure");
}
}
else
{
throw new ArgumentNullException("workFieldDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw;
}
}
return(workFieldDTO);
}
public GroupDTO UpdateGroupinDB(GroupDTO groupDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapGroupAsInput(groupDTO))
{
// 2- Select Group to be updated
GroupBusiness groupBusiness = new GroupBusiness();
GroupList groupList = groupBusiness.SelectRows(Mapper._Group.Id, null);
if (groupList != null && groupList.Count > 0)
{
groupList[0].name = Mapper._Group.name;
groupList[0].status = Mapper._Group.status;
// 3- Update Group Data by Input Values
groupBusiness = new GroupBusiness();
if (groupBusiness.UpdateRow(dbTransaction, groupList[0]) > 0)
{
// 4- Remove Group Functions Already Saved for that Group in DB
GroupFunctionBusiness groupFunctionBusiness = new GroupFunctionBusiness();
GroupFunctionList groupFunctionList = groupFunctionBusiness.SelectRows(null, null, Mapper._Group.Id);
if (groupFunctionList != null && groupFunctionList.Count > 0)
{
foreach (GroupFunction groupFunction in groupFunctionList)
{
groupFunctionBusiness = new GroupFunctionBusiness();
groupFunctionBusiness.DeleteRow(dbTransaction, groupFunction);
}
}
// 5- Add New Group Functions from Input
if (Mapper._GroupFunctionListInput != null && Mapper._GroupFunctionListInput.Count > 0)
{
foreach (GroupFunction groupFunction in Mapper._GroupFunctionListInput)
{
groupFunctionBusiness = new GroupFunctionBusiness();
groupFunctionBusiness.InsertRow(dbTransaction, groupFunction);
}
dbTransaction.Commit();
}
}
else
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
else
{
throw new Exception("Group Id Not Found in DB");
}
}
else
{
throw new ArgumentNullException("groupDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
return(groupDTO);
}
public RequestDTO UpdateRequestinDB(RequestDTO requestDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapRequestAsInput(requestDTO))
{
// 2- Select Request to be updated
RequestBusiness requestBusiness = new RequestBusiness();
RequestList requestList = requestBusiness.SelectRows(Mapper._Request.Id, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null);
if (requestList != null && requestList.Count > 0)
{
requestList[0].requestNumber = Mapper._Request.requestNumber;
requestList[0].totalQuantity = Mapper._Request.totalQuantity;
requestList[0].PDD = Mapper._Request.PDD;
requestList[0].customerID = Mapper._Request.customerID;
requestList[0].creationDate = Mapper._Request.creationDate;
requestList[0].creationUserID = Mapper._Request.creationUserID;
requestList[0].approvalDate = Mapper._Request.approvalDate;
requestList[0].approvalUserID = Mapper._Request.approvalUserID;
requestList[0].receiveDate = Mapper._Request.receiveDate;
requestList[0].receiveUserID = Mapper._Request.receiveUserID;
requestList[0].rejectionDate = Mapper._Request.rejectionDate;
requestList[0].rejectionUserID = Mapper._Request.rejectionUserID;
requestList[0].rejectionReasonID = Mapper._Request.rejectionReasonID;
requestList[0].requestTypeID = Mapper._Request.requestTypeID;
requestList[0].requestStatusID = Mapper._Request.requestStatusID;
requestList[0].requestCalssID = Mapper._Request.requestCalssID;
requestList[0].requestPriorityID = Mapper._Request.requestPriorityID;
// 3- Update Request Data by Input Values
requestBusiness = new RequestBusiness();
if (requestBusiness.UpdateRow(dbTransaction, requestList[0]) > 0)
{
// 4- Remove Request Details Already Saved for that Request in DB
RequestDetailBusiness requestDetailBusiness = new RequestDetailBusiness();
RequestDetailList requestDetailList = requestDetailBusiness.SelectRows(null, null, Mapper._Request.Id);
if (requestDetailList != null && requestDetailList.Count > 0)
{
foreach (RequestDetail requestDetail in requestDetailList)
{
requestDetailBusiness = new RequestDetailBusiness();
requestDetailBusiness.DeleteRow(dbTransaction, requestDetail);
}
}
// 5- Add New Request Details from Input
if (Mapper._RequestDetailListInput != null && Mapper._RequestDetailListInput.Count > 0)
{
foreach (RequestDetail requestDetail in Mapper._RequestDetailListInput)
{
requestDetailBusiness = new RequestDetailBusiness();
requestDetailBusiness.InsertRow(dbTransaction, requestDetail);
}
dbTransaction.Commit();
}
}
else
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
else
{
throw new Exception("Request Id Not Found in DB");
}
}
else
{
throw new ArgumentNullException("requestDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
return(requestDTO);
}
public RequestDTO AddRequesttoDB(RequestDTO requestDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapRequestAsInput(requestDTO))
{
////User user = Mapper._User;
////List<UserGroup> userGroups = Mapper._UserGroupListInput;
//Mapper._User.createDate = DateTime.Now;
Mapper._Request.creationDate = DateTime.Now;
// 2- Insert Request in DB
RequestBusiness requestBusiness = new RequestBusiness();
if (requestBusiness.InsertRow(dbTransaction, Mapper._Request) > 0)
{
requestDTO.Id = Mapper._Request.Id;
if (Mapper._RequestDetailListInput != null && Mapper._RequestDetailListInput.Count > 0)
{
RequestDetailBusiness requestDetailBusiness = new RequestDetailBusiness();
// 3- Insert Group Functions in DB
foreach (RequestDetail requestDetail in Mapper._RequestDetailListInput)
{
requestDetail.requestID = Mapper._Request.Id;
requestDetailBusiness = new RequestDetailBusiness();
requestDetailBusiness.InsertRow(dbTransaction, requestDetail);
}
dbTransaction.Commit();
}
else
{
dbTransaction.Rollback();
}
}
else
{
throw new Exception("DataBase Operation Failure");
}
}
else
{
throw new ArgumentNullException("requestDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw;
}
}
return(requestDTO);
}
public UserDTO UpdateUserinDB(UserDTO userDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapUserAsInput(userDTO))
{
////User user = Mapper._User;
////List<UserGroup> userGroups = Mapper._UserGroupListInput;
//UserBusiness userBusiness = new UserBusiness();
//if (userBusiness.InsertRow(dbTransaction, Mapper._User) > 0)
//{
// UserGroupBusiness userGroupBusiness = new UserGroupBusiness();
// if (Mapper._UserGroupListInput != null && Mapper._UserGroupListInput.Count > 0)
// {
// foreach (UserGroup userGroup in Mapper._UserGroupListInput)
// {
// userGroup.userId = Mapper._User.Id;
// userGroupBusiness = new UserGroupBusiness();
// userGroupBusiness.InsertRow(dbTransaction, userGroup);
// }
// dbTransaction.Commit();
// }
// else
// dbTransaction.Rollback();
//}
//else
// throw new DataException("DataBase Operation Failure");
// 2- Select User to be updated
UserBusiness userBusiness = new UserBusiness();
UserList userList = userBusiness.SelectRows(Mapper._User.Id, null, null, null);
if (userList != null && userList.Count > 0)
{
userList[0].userName = Mapper._User.userName;
userList[0].fullName = Mapper._User.fullName;
userList[0].Password = Mapper._User.Password;
userList[0].status = Mapper._User.status;
// 3- Update User Data by Input Values
userBusiness = new UserBusiness();
if (userBusiness.UpdateRow(dbTransaction, userList[0]) > 0)
{
// 4- Remove User Groups Already Saved for that User in DB
UserGroupBusiness userGroupBusiness = new UserGroupBusiness();
UserGroupList userGroupList = userGroupBusiness.SelectRows(null, Mapper._User.Id, null);
if (userGroupList != null && userGroupList.Count > 0)
{
//foreach (UserGroup userGroup in Mapper._UserGroupList)
//{
// userGroupBusiness = new UserGroupBusiness();
// userGroupBusiness.DeleteRow(dbTransaction, userGroup);
//}
foreach (UserGroup userGroup in userGroupList)
{
userGroupBusiness = new UserGroupBusiness();
userGroupBusiness.DeleteRow(dbTransaction, userGroup);
}
}
// 5- Add New User Groups from Input
if (Mapper._UserGroupListInput != null && Mapper._UserGroupListInput.Count > 0)
{
foreach (UserGroup userGroup in Mapper._UserGroupListInput)
{
userGroupBusiness = new UserGroupBusiness();
userGroupBusiness.InsertRow(dbTransaction, userGroup);
}
dbTransaction.Commit();
}
}
else
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
else
{
throw new Exception("User Id Not Found in DB");
}
}
else
{
throw new ArgumentNullException("userDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
return(userDTO);
}
public GroupDTO AddGrouptoDB(GroupDTO groupDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapGroupAsInput(groupDTO))
{
////User user = Mapper._User;
////List<UserGroup> userGroups = Mapper._UserGroupListInput;
//Mapper._User.createDate = DateTime.Now;
// 2- Insert Group in DB
GroupBusiness groupBusiness = new GroupBusiness();
if (groupBusiness.InsertRow(dbTransaction, Mapper._Group) > 0)
{
groupDTO.Id = Mapper._Group.Id;
if (Mapper._GroupFunctionListInput != null && Mapper._GroupFunctionListInput.Count > 0)
{
GroupFunctionBusiness groupFunctionBusiness = new GroupFunctionBusiness();
// 3- Insert Group Functions in DB
foreach (GroupFunction groupFunction in Mapper._GroupFunctionListInput)
{
groupFunction.groupId = Mapper._Group.Id;
groupFunctionBusiness = new GroupFunctionBusiness();
groupFunctionBusiness.InsertRow(dbTransaction, groupFunction);
}
dbTransaction.Commit();
}
else
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
else
{
throw new Exception("Group Id Not Found in DB");
}
}
else
{
throw new ArgumentNullException("groupDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
return(groupDTO);
}
public UserDTO AddUsertoDB(UserDTO userDTO)
{
BaseDataAccess _db = new BaseDataAccess();
using (DbTransaction dbTransaction = _db.CreateTransaction())
{
try
{
// 1- Perform Mapping to Input (for Saving in DB)
if (Mapper.MapUserAsInput(userDTO))
{
//User user = Mapper._User;
//List<UserGroup> userGroups = Mapper._UserGroupListInput;
Mapper._User.createDate = DateTime.Now;
// 2- Insert User in DB
UserBusiness userBusiness = new UserBusiness();
if (userBusiness.InsertRow(dbTransaction, Mapper._User) > 0)
{
userDTO.Id = Mapper._User.Id;
if (Mapper._UserGroupListInput != null && Mapper._UserGroupListInput.Count > 0)
{
UserGroupBusiness userGroupBusiness = new UserGroupBusiness();
// 3- Insert User Groups in DB
foreach (UserGroup userGroup in Mapper._UserGroupListInput)
{
userGroup.userId = Mapper._User.Id;
userGroupBusiness = new UserGroupBusiness();
userGroupBusiness.InsertRow(dbTransaction, userGroup);
}
dbTransaction.Commit();
}
else
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
else
{
throw new Exception("DataBase Operation Failure");
}
}
else
{
throw new ArgumentNullException("userDTO");
}
}
catch (Exception ex)
{
dbTransaction.Rollback();
throw new Exception("DataBase Operation Failure");
}
}
return(userDTO);
}
