private RoleDC FillObject(DataRow row)
{
RoleDC objRole = null;
objRole = new RoleDC();
objRole.RoleID = (String)row["RoleID"];
objRole.RoleDescription = (String)row["RoleDescription"];
objRole.SerialNo = (int)row["SerialNo"];
objRole.CanView = (Boolean)row["CanView"];
objRole.CanAdd = (Boolean)row["CanAdd"];
objRole.CanEdit = (Boolean)row["CanEdit"];
objRole.CanDelete = (Boolean)row["CanDelete"];
objRole.CanPrint = (Boolean)row["CanPrint"];
objRole.AddBy = (string)row["AddBy"];
objRole.AddOn = row["AddOn"] == DBNull.Value ? null : (DateTime?)row["AddOn"];
objRole.EditBy = (string)row["EditBy"];
objRole.EditOn = (DateTime)row["EditOn"];
objRole.IsSyncReq = (Boolean)row["IsSyncReq"];
objRole.IsSync = (Boolean)row["IsSync"];
objRole.RowState = (string)row["RowState"];
objRole.SyncDate = row["SyncDate"] == DBNull.Value ? null : (DateTime?)row["SyncDate"];
objRole.CompanyID = row["CompanyID"] == DBNull.Value ? null : (int?)row["CompanyID"];
return(objRole);
}
public RoleDC LoadByPrimaryKey(DBConnection Connection, string RoleID)
{
RoleDC objRole = new RoleDC();
StringBuilder sql = new StringBuilder();
sql.Append("proc_RolesLoadByPrimaryKey");
DBCommandWarpper dbCommandWrapper = new DBCommandWarpper(Connection.dataBase.GetStoredProcCommand(sql.ToString()), Connection);
dbCommandWrapper.AddInParameter("p_RoleID", DbType.String, RoleID);
IDataReader reader = null;
if (Connection.Transaction != null)
{
reader = Connection.dataBase.ExecuteReader(dbCommandWrapper.DBCommand, Connection.Transaction);
}
else
{
reader = Connection.dataBase.ExecuteReader(dbCommandWrapper.DBCommand);
}
objRole = FillObject(reader);
return(objRole);
}
private RoleDC FillObject(IDataReader reader)
{
RoleDC objRole = null;
if (reader != null && reader.Read())
{
objRole = new RoleDC();
objRole.RoleID = (String)reader["RoleID"];
objRole.RoleDescription = (String)reader["RoleDescription"];
objRole.SerialNo = (int)reader["SerialNo"];
objRole.CanView = (Boolean)reader["CanView"];
objRole.CanAdd = (Boolean)reader["CanAdd"];
objRole.CanEdit = (Boolean)reader["CanEdit"];
objRole.CanDelete = (Boolean)reader["CanDelete"];
objRole.CanPrint = (Boolean)reader["CanPrint"];
objRole.AddBy = (string)reader["AddBy"];
objRole.AddOn = (DateTime)reader["AddOn"];
objRole.EditBy = (string)reader["EditBy"];
objRole.EditOn = (DateTime)reader["EditOn"];
objRole.IsSyncReq = (Boolean)reader["IsSyncReq"];
objRole.IsSync = (Boolean)reader["IsSync"];
objRole.RowState = (string)reader["RowState"];
objRole.SyncDate = reader["SyncDate"] == DBNull.Value ? null : (DateTime?)reader["SyncDate"];
objRole.CompanyID = reader["CompanyID"] == DBNull.Value ? null : (int?)reader["CompanyID"];
reader.Close();
reader.Dispose();
}
return(objRole);
}
/// <summary>
/// AddRole
/// </summary>
/// <param name="roleModel"></param>
public void SaveRole(RoleModel roleModel)
{
RoleDC roleRequest = Mapper.Map <RoleModel, RoleDC>(roleModel);
ServiceResponse <int> saveRoleResponse = _securityProxy.Execute(opt => opt.SaveRole(roleRequest));
if (saveRoleResponse.Status != ResponseStatus.Success)
{
HandleError(saveRoleResponse.Status, saveRoleResponse.ResponseMessage);
}
else
{
roleModel.RoleId = saveRoleResponse.Result;
}
}
/// <summary>
/// SaveRole
/// </summary>
/// <param name="role"></param>
/// <returns></returns>
public ServiceResponse <int> SaveRole(RoleDC role)
{
ServiceResponse <int> saveRoleResponse = new ServiceResponse <int>();
try
{
SetContext();
Role roleModel = Mapper.Map <RoleDC, Role>(role);
_securityManager.SaveRole(roleModel);
saveRoleResponse.Result = roleModel.RoleId;
}
catch (Exception ex)
{
HandleError(ex, saveRoleResponse);
}
return(saveRoleResponse);
}
private int Update(DBConnection Connection, RoleDC objRole)
{
int updateCount = 0;
StringBuilder sql = new StringBuilder();
sql.Append("proc_RolesUpdate");
DBCommandWarpper dbCommandWrapper = new DBCommandWarpper(Connection.dataBase.GetStoredProcCommand(sql.ToString()), Connection);
dbCommandWrapper.AddInParameter("p_RoleID", DbType.String, objRole.RoleID);
dbCommandWrapper.AddInParameter("p_RoleDescription", DbType.String, objRole.RoleDescription);
dbCommandWrapper.AddInParameter("p_SerialNo", DbType.Int32, objRole.SerialNo);
dbCommandWrapper.AddInParameter("p_CanView", DbType.Boolean, objRole.CanView);
dbCommandWrapper.AddInParameter("p_CanAdd", DbType.Boolean, objRole.CanAdd);
dbCommandWrapper.AddInParameter("p_CanEdit", DbType.Boolean, objRole.CanEdit);
dbCommandWrapper.AddInParameter("p_CanDelete", DbType.Boolean, objRole.CanDelete);
dbCommandWrapper.AddInParameter("p_CanPrint", DbType.Boolean, objRole.CanPrint);
dbCommandWrapper.AddInParameter("p_AddBy", DbType.AnsiStringFixedLength, objRole.AddBy);
dbCommandWrapper.AddInParameter("p_AddOn", DbType.DateTime, objRole.AddOn);
dbCommandWrapper.AddInParameter("p_EditBy", DbType.String, objRole.EditBy);
dbCommandWrapper.AddInParameter("p_EditOn", DbType.DateTime, objRole.EditOn);
dbCommandWrapper.AddInParameter("p_IsSyncReq", DbType.Boolean, objRole.IsSyncReq);
dbCommandWrapper.AddInParameter("p_IsSync", DbType.Boolean, objRole.IsSync);
dbCommandWrapper.AddInParameter("p_RowState", DbType.AnsiStringFixedLength, objRole.RowState);
dbCommandWrapper.AddInParameter("p_SyncDate", DbType.DateTime, objRole.SyncDate);
dbCommandWrapper.AddInParameter("p_CompanyID", DbType.Int32, objRole.CompanyID);
if (Connection.Transaction != null)
{
updateCount = Connection.dataBase.ExecuteNonQuery(dbCommandWrapper.DBCommand, Connection.Transaction);
}
else
{
updateCount = Connection.dataBase.ExecuteNonQuery(dbCommandWrapper.DBCommand);
}
if (updateCount == 0)
{
objRole.IsDirty = IsDirty = true;
}
return(updateCount);
}
public RoleDC LoadByPrimaryKey(string RoleID)
{
DBConnection objConnection = new DBConnection();
RoleDA objRoleDA = new RoleDA();
RoleDC objRoleDC = null;
try
{
objConnection.Open(false);
objRoleDC = objRoleDA.LoadByPrimaryKey(objConnection, RoleID);
}
catch (Exception ex)
{
throw ex;
}
finally
{
objConnection.Close();
}
return(objRoleDC);
}
private int Delete(DBConnection Connection, RoleDC objRole)
{
int deleteCount = 0;
StringBuilder sql = new StringBuilder();
sql.Append("proc_RolesDelete");
DBCommandWarpper dbCommandWrapper = new DBCommandWarpper(Connection.dataBase.GetStoredProcCommand(sql.ToString()), Connection);
dbCommandWrapper.AddInParameter("p_RoleID", DbType.String, objRole.RoleID);
if (Connection.Transaction != null)
{
deleteCount = Connection.dataBase.ExecuteNonQuery(dbCommandWrapper.DBCommand, Connection.Transaction);
}
else
{
deleteCount = Connection.dataBase.ExecuteNonQuery(dbCommandWrapper.DBCommand);
}
return(deleteCount);
}
//This method is shared between create and save
private ActionResult UpdateRole()
{
// Get the updated model
var model = GetUpdatedModel();
// Test to see if there are any errors
var errors = ModelState
.Where(x => x.Value.Errors.Count > 0)
.Select(x => new { x.Key, x.Value.Errors[0].ErrorMessage })
.ToArray();
//Set flags false
SetFlagsFalse(model);
// Test to see if the model has validated correctly
if (ModelState.IsValid)
{
// Create service instance
IUcbService sc = UcbService;
//Attempt update
try
{
// Map model to data contract
RoleDC RoleItem = Mapper.Map <RoleDC>(model.RoleItem);
RoleVMDC returnedObject = null;
if (null == model.RoleItem.Code || model.RoleItem.Code == Guid.Empty)
{
// Call service to create new Role item
returnedObject = sc.CreateRole(CurrentUser, CurrentUser, appID, "", RoleItem);
}
else
{
// Call service to update Role item
returnedObject = sc.UpdateRole(CurrentUser, CurrentUser, appID, "", RoleItem);
}
// Close service communication
((ICommunicationObject)sc).Close();
// Retrieve item returned by service
var createdRole = returnedObject.RoleItem;
// Map data contract to model
model.RoleItem = Mapper.Map <RoleModel>(createdRole);
//After creation some of the fields are display only so we need the resolved look up nmames
ResolveFieldCodesToFieldNamesUsingLists(model);
// Set access context to Edit mode
model.AccessContext = RoleAccessContext.Edit;
// Save version of item returned by service into session
sessionManager.RoleServiceVersion = model.RoleItem;
sessionManager.CurrentRole = model.RoleItem;
// Remove the state from the model as these are being populated by the controller and the HTML helpers are being populated with
// the POSTED values and not the changed ones.
ModelState.Clear();
model.Message = Resources.MESSAGE_UPDATE_SUCCEEDED;
}
catch (Exception e)
{
// Handle the exception
string message = ExceptionManager.HandleException(e, (ICommunicationObject)sc);
model.Message = message;
return(View(model));
}
}
return(View(model));
}
/// <summary>
/// Create a Role
/// </summary>
/// <param name="currentUser"></param>
/// <param name="user"></param>
/// <param name="appID"></param>
/// <param name="overrideID"></param>
/// <param name="dc"></param>
/// <param name="dataRepository"></param>
/// <param name="uow"></param>
public RoleVMDC CreateRole(string currentUser, string user, string appID, string overrideID, RoleDC dc, IRepository <Role> dataRepository, IUnitOfWork uow, IExceptionManager exceptionManager, IMappingService mappingService)
{
try
{
#region Parameter validation
// Validate parameters
if (string.IsNullOrEmpty(currentUser))
{
throw new ArgumentOutOfRangeException("currentUser");
}
if (string.IsNullOrEmpty(user))
{
throw new ArgumentOutOfRangeException("user");
}
if (string.IsNullOrEmpty(appID))
{
throw new ArgumentOutOfRangeException("appID");
}
if (null == dc)
{
throw new ArgumentOutOfRangeException("dc");
}
if (null == dataRepository)
{
throw new ArgumentOutOfRangeException("dataRepository");
}
if (null == uow)
{
throw new ArgumentOutOfRangeException("uow");
}
if (null == exceptionManager)
{
throw new ArgumentOutOfRangeException("exceptionManager");
}
if (null == mappingService)
{
throw new ArgumentOutOfRangeException("mappingService");
}
#endregion
using (uow)
{
// Create a new ID for the Role item
dc.Code = Guid.NewGuid();
// Map data contract to model
Role destination = mappingService.Map <RoleDC, Role>(dc);
// Add the new item
dataRepository.Add(destination);
// Commit unit of work
uow.Commit();
// Map model back to data contract to return new row id.
dc = mappingService.Map <Role, RoleDC>(destination);
}
// Create aggregate data contract
RoleVMDC returnObject = new RoleVMDC();
// Add new item to aggregate
returnObject.RoleItem = dc;
return(returnObject);
}
catch (Exception e)
{
//Prevent exception from propogating across the service interface
exceptionManager.ShieldException(e);
return(null);
}
}
/// <summary>
/// Retrieve a Role with associated lookups
/// </summary>
/// <param name="currentUser"></param>
/// <param name="user"></param>
/// <param name="appID"></param>
/// <param name="overrideID"></param>
/// <param name="code"></param>
/// <param name="dataRepository"></param>
/// <param name="uow"></param>
/// <returns></returns>
public RoleVMDC GetRole(string currentUser, string user, string appID, string overrideID, string code, IUnitOfWork uow, IRepository <Role> dataRepository
, IRepository <Application> applicationRepository
, IExceptionManager exceptionManager, IMappingService mappingService)
{
try
{
#region Parameter validation
// Validate parameters
if (string.IsNullOrEmpty(currentUser))
{
throw new ArgumentOutOfRangeException("currentUser");
}
if (string.IsNullOrEmpty(user))
{
throw new ArgumentOutOfRangeException("user");
}
if (string.IsNullOrEmpty(appID))
{
throw new ArgumentOutOfRangeException("appID");
}
if (null == dataRepository)
{
throw new ArgumentOutOfRangeException("dataRepository");
}
if (null == uow)
{
throw new ArgumentOutOfRangeException("uow");
}
if (null == exceptionManager)
{
throw new ArgumentOutOfRangeException("exceptionManager");
}
if (null == mappingService)
{
throw new ArgumentOutOfRangeException("mappingService");
}
#endregion
using (uow)
{
RoleDC destination = null;
// If code is null then just return supporting lists
if (!string.IsNullOrEmpty(code))
{
// Convert code to Guid
Guid codeGuid = Guid.Parse(code);
// Retrieve specific Role
Role dataEntity = dataRepository.Single(x => x.Code == codeGuid);
// Convert to data contract for passing through service interface
destination = mappingService.Map <Role, RoleDC>(dataEntity);
}
IEnumerable <Application> applicationList = applicationRepository.GetAll(x => new { x.Description });
List <ApplicationDC> applicationDestinationList = mappingService.Map <List <ApplicationDC> >(applicationList);
// Create aggregate contract
RoleVMDC returnObject = new RoleVMDC();
returnObject.RoleItem = destination;
returnObject.ApplicationList = applicationDestinationList;
return(returnObject);
}
}
catch (Exception e)
{
//Prevent exception from propogating across the service interface
exceptionManager.ShieldException(e);
return(null);
}
}
/// <summary>
/// Create a Role
/// </summary>
/// <param name="currentUser"></param>
/// <param name="user"></param>
/// <param name="appID"></param>
/// <param name="overrideID"></param>
/// <param name="dc"></param>
public RoleVMDC CreateRole(string currentUser, string user, string appID, string overrideID, RoleDC dc)
{
// Create unit of work
IUnitOfWork uow = new UnitOfWork(currentUser);
// Create repository
Repository <Role> dataRepository = new Repository <Role>(uow.ObjectContext, currentUser, user, appID, overrideID);
//Create ExceptionManager
IExceptionManager exceptionManager = new ExceptionManager();
//Create MappingService
IMappingService mappingService = new MappingService();
// Call overload with injected objects
return(CreateRole(currentUser, user, appID, overrideID, dc, dataRepository, uow, exceptionManager, mappingService));
}
