public async Task UpdateAsync(Guid id, SubDepartmentModel model)
{
var entity = await DataContext.Departments.FindAsync(id);
if (entity == null)
{
throw new NotFoundException();
}
_mapper.Map(model, entity);
await DataContext.SaveChangesAsync();
}
public ActionResult Create()
{
int OrgID = int.Parse(Request.Cookies["OrgID"].Value);
OrganizationModel orgmodel = new OrganizationService().GetOrganizationByID(OrgID);
ViewBag.Departments = orgmodel.Departments;
SubDepartmentModel model = new SubDepartmentModel();
model.SubDepartmentID = 0;
return(View(model));
}
public SubDepartmentModel GetSubDepartmentDetail(int deptid)
{
SubDepartmentModel model = new SubDepartmentModel();
DataSet ds = Db.ExecuteDataSet("prcGetSubDepartmentDetails", CommandType.StoredProcedure,
Db.CreateParameter("@SubDepartmentID", deptid)
);
if (ds != null && ds.Tables.Count > 0 && ds.Tables[0].Rows.Count > 0)
{
IList <SubDepartmentModel> sdInfo = Db.MapReader <SubDepartmentModel>(ds.Tables[0]);
model = sdInfo[0];
}
return(model);
}
public async Task <CreateResponse> CreateAsync(SubDepartmentModel model)
{
var entity = new SubDepartment
{
Id = SequentialGuid.NewGuid()
};
DataContext.SubDepartments.Add(entity);
_mapper.Map(model, entity);
await DataContext.SaveChangesAsync();
return(new CreateResponse {
Id = entity.Id
});
}
public JsonResult Save(SubDepartmentModel model)
{
int newDeptId = 0;
try
{
if (ModelState.IsValid)
{
if (model.DepartmentID == 0)
{
throw new ApplicationException("Please create department before creating sub departments.");
}
newDeptId = new SubDepartmentFacade().CreateOrModify(model);
}
}
catch (Exception ex)
{
return(this.Json("{\"Error\": \"" + ex.Message + "\"}"));
}
string jsonResult = "{\"ID\":\"" + newDeptId + "\",\"Name\": \"" + model.SubDepartmentName + "\"}";
return(this.Json(jsonResult));
}
public int CreateOrModify(SubDepartmentModel model)
{
int deptId = (int)Db.ExecuteScalar("prcSaveSubDepartment", CommandType.StoredProcedure,
Db.CreateParameter("@DepartmentID", model.DepartmentID),
Db.CreateParameter("@SubDepartmentID", model.SubDepartmentID),
Db.CreateParameter("@SubDepartmentName", model.SubDepartmentName),
Db.CreateParameter("@SubDepartmentAbbreviate", model.SubDepartmentAbbreviate),
Db.CreateParameter("@HODName", model.HODName),
Db.CreateParameter("@LLNumber", model.LLNumber),
Db.CreateParameter("@MobileNumber", model.MobileNumber),
Db.CreateParameter("@EmailId", model.EmailId),
Db.CreateParameter("@ReviewerName", model.ReviewerName),
Db.CreateParameter("@ReviewerLLNumber", model.ReviewerLLNumber),
Db.CreateParameter("@ReviewerMobileNumber", model.ReviewerMobileNumber),
Db.CreateParameter("@ReviewerEmailID", model.ReviewerEmailID),
Db.CreateParameter("@IsHODApprover", model.IsHODApprover ? 1 : 0),
Db.CreateParameter("@ApproverName", model.ApproverName),
Db.CreateParameter("@ApproverLLNumber", model.ApproverLLNumber),
Db.CreateParameter("@ApproverMobileNumber", model.ApproverMobileNumber),
Db.CreateParameter("@ApproverEmailID", model.ApproverEmailID)
);
return(deptId);
}
public Task UpdateAsync(Guid id, [FromBody] SubDepartmentModel model)
{
return(SubDepartmentService.UpdateAsync(id, model));
}
public Task <CreateResponse> CreateAsync([FromBody] SubDepartmentModel model)
{
return(SubDepartmentService.CreateAsync(model));
}
public static OrganizationModel GetDepartmentRoleGroups(int userId, int orgid)
{
OrganizationModel org = new OrganizationFacade().GetOrganization(orgid);
DataSet configDataSet = Db.ExecuteDataSet("prcGetUserRoleGroupConfiguration", CommandType.StoredProcedure,
Db.CreateParameter("@UserID", userId)
);
if (configDataSet != null && configDataSet.Tables.Count > 1)
{
List <UserRoleGroup> configList = new List <UserRoleGroup>();
if (configDataSet.Tables[0] != null && configDataSet.Tables[0].Rows.Count > 0)
{
configList = Db.MapReader <UserRoleGroup>(configDataSet.Tables[0]).ToList();
}
List <RoleGroup> rgList = Db.MapReader <RoleGroup>(configDataSet.Tables[1]).ToList();
foreach (DepartmentModel dept in org.Departments)
{
if (dept.SubDepartments != null && dept.SubDepartments.Count > 0)
{
foreach (SubDepartmentModel subdept in dept.SubDepartments)
{
subdept.SubDepartmentRoleGroups = rgList.ConvertAll(rolegroup => new RoleGroup()
{
RoleGroupID = rolegroup.RoleGroupID, RoleGroupName = rolegroup.RoleGroupName
});
}
}
else
{
dept.DepartmentRoleGroups = rgList.ConvertAll(rolegroup => new RoleGroup()
{
RoleGroupID = rolegroup.RoleGroupID, RoleGroupName = rolegroup.RoleGroupName
});
}
}
// loop thriugh user groups and build list
foreach (UserRoleGroup rgconf in configList)
{
// find department else subdepartments to map data
int deptid = rgconf.DepartmentID;
int subdeptid = rgconf.SubDepartmentID;
int rolegroupid = rgconf.RoleGroupID;
if (deptid > 0)
{
DepartmentModel deptModel = org.Departments.Find(delegate(DepartmentModel _field)
{
if (_field.DepartmentID == deptid)
{
return(true);
}
return(false);
});
if (deptModel != null)
{
if (subdeptid > 0)
{
SubDepartmentModel subdeptmodel = deptModel.SubDepartments.Find(delegate(SubDepartmentModel _field)
{
if (_field.SubDepartmentID == subdeptid)
{
return(true);
}
return(false);
});
if (subdeptmodel != null)
{
RoleGroup sdrolegroup = subdeptmodel.SubDepartmentRoleGroups.Find(delegate(RoleGroup _field)
{
if (_field.RoleGroupID == rolegroupid)
{
return(true);
}
return(false);
});
if (sdrolegroup != null)
{
sdrolegroup.IsGranted = Convert.ToBoolean(rgconf.IsActive);
sdrolegroup.UserRoleGroupID = rgconf.UserRoleGroupID;
}
}
}
else
{
RoleGroup sdrolegroup = deptModel.DepartmentRoleGroups.Find(delegate(RoleGroup _field)
{
if (_field.RoleGroupID == rolegroupid)
{
return(true);
}
return(false);
});
if (sdrolegroup != null)
{
sdrolegroup.IsGranted = Convert.ToBoolean(rgconf.IsActive);
sdrolegroup.UserRoleGroupID = rgconf.UserRoleGroupID;
}
}
}
}
}
}
return(org);
}
public void Add(SubDepartmentModel subDepartment)
{
context.SubDepartments.Add(subDepartment);
}
