public List <AllAgileBoardListObjects> GetAllAgileBoards()
{
var result = new List <AllAgileBoardListObjects>();
try
{
using (var context = new IssueTrackerEntities())
{
result = (from agile in context.AgileBoards.Where(i => i.IsActive)
from agileProject in context.AgileBoardProjectMappers.Where(i => i.IsActive && i.AgileBoardId == agile.AgileBoardId)
from project in context.Projects.Where(i => i.IsActive && i.ProjectId == agileProject.ProjectId)
from admin in context.AgileBoardAdminMappers.Where(i => i.AgileBoardId == agile.AgileBoardId)
from adminUserName in context.Users.Where(i => i.IsActive && i.UserId == admin.AdminUserId)
select new AllAgileBoardListObjects()
{
AgileBoardId = agile.AgileBoardId,
AgileBoardName = agile.AgileBoardName,
Admin = adminUserName.DisplayName,
ProjectName = project.ProjectName
}).OrderBy(j => j.AgileBoardName).ToList();
}
}
catch (Exception ex)
{ }
return(result);
}
public TaskDetails GetTaskDetails(string TaskId)
{
TaskDetails task = new TaskDetails();
using (var taskEntities = new IssueTrackerEntities())
{
task = (from details in taskEntities.IssueDetails
where details.TaskId == TaskId && details.IsActive
join component in taskEntities.Components on details.ComponentId equals component.ComponentId
where component.IsActive
join issueType in taskEntities.IssueTypes on details.IssueTypeId equals issueType.IssueTypeId
where issueType.IsActive
join priotity in taskEntities.Priorities on details.PriorityId equals priotity.PriorityId
where priotity.IsActive == 1
join status in taskEntities.Statuses on details.StatusId equals status.StatusId
where status.IsActive
join engineer in taskEntities.Users on details.EngineerId equals engineer.UserId
where engineer.IsActive
join reporter in taskEntities.Users on details.ReportingPersionId equals reporter.UserId
where reporter.IsActive
join assignee in taskEntities.Users on details.AssigneeId equals assignee.UserId
where assignee.IsActive
join version in taskEntities.ReleaseVersions on details.ReleaseVerionId equals version.ReleaseVersionId
select new TaskDetails()
{
IssueID = details.IssueId,
TaskId = details.TaskId,
Title = details.Title,
ComponentId = details.ComponentId,
ComponentName = component.ComponentName,
IssueTypeId = details.IssueTypeId,
IssueTypeName = issueType.IssueTypeName,
PriorityId = details.PriorityId,
PriorityName = priotity.PriorityName,
Description = details.Description,
StatusId = details.StatusId,
StatusName = status.StatusName,
EngineerId = details.EngineerId,
EngineerName = engineer.DisplayName,
ReporterId = details.ReportingPersionId,
ReporterName = reporter.DisplayName,
AssigneeId = details.AssigneeId,
AssigneeName = assignee.DisplayName,
//ReleaseVersionId = (int)details.ReleaseVerionId,
ReleaseVersionName = version.VersionName,
//StoryPoints = (int)details.StoryPoints,
DueDate = (DateTime)details.DueDate,
CreatedDate = (DateTime)details.CreatedDate,
ModifiedDate = (DateTime)details.ModifiedDate
}).FirstOrDefault();
}
return(task);
}
public SelectList GetAdmin()
{
using (var context = new IssueTrackerEntities())
{
var adminList = (from users in context.Users
where users.IsActive && users.RoleId == 1
select users).ToDictionary(a => a.UserId, b => b.DisplayName);
adminList.OrderBy(k => k.Value);
return(new SelectList(adminList, "Key", "Value"));
}
}
public SelectList GetProject()
{
using (var context = new IssueTrackerEntities())
{
var proectList = (from project in context.Projects
where project.IsActive
select project).ToDictionary(a => a.ProjectId, b => b.ProjectName);
proectList.OrderBy(k => k.Value);
return(new SelectList(proectList, "Key", "Value"));
}
}
public List <ProjectDetails> GetProjectList()
{
var Entity = new IssueTrackerEntities();
var ProjectDetailsData = from projects in Entity.Projects join Users in Entity.Users on projects.ProjectLeadUserId equals Users.UserId
where projects.IsActive == true && Users.IsActive == true
select new ProjectDetails
{
Projectkey = projects.ProjectKey,
ProjectName = projects.ProjectName,
ProjectLead = Users.DisplayName,
// ProjectComponents = components.PriorityName,
};
List <ProjectDetails> selectedCollection = ProjectDetailsData.ToList();
return(selectedCollection);
}
public KanbanBoardResult GetTaskListForKanbanBoard(int agileBoardId)
{
var result = new KanbanBoardResult();
result.TaskListResult = new List <KanbanBoardObjects>();
try
{
using (var context = new IssueTrackerEntities())
{
var res = (from agile in context.AgileBoards.Where(i => i.IsActive && i.AgileBoardId == agileBoardId) select agile).FirstOrDefault();
if (res != null)
{
result.AgileBoardId = res.AgileBoardId;
result.AgileBoardName = res.AgileBoardName;
result.SwimlanesBy = (res.SwimlanesBy != null) ? GetSwimlaneName((int)res.SwimlanesBy) : "None";
}
result.TaskListResult = (from task in context.IssueDetails.Where(i => i.IsActive)
from issueType in context.IssueTypes.Where(i => i.IsActive && i.IssueTypeId == task.IssueTypeId)
from status in context.Statuses.Where(i => i.IsActive && i.StatusId == task.StatusId)
from assginee in context.Users.Where(i => i.UserId == task.AssigneeId)
select new KanbanBoardObjects()
{
IssueId = task.IssueId,
TaskId = task.TaskId,
Title = task.Title,
StoryPointsInDecmial = task.StoryPoints,
IssueType = issueType.IssueTypeName,
Status = status.StatusName,
Assignee = assginee.DisplayName
}).ToList();
if (result.TaskListResult != null && result.TaskListResult.Count > 0)
{
result.TaskListResult.ForEach(i => i.StoryPoint = (i.StoryPointsInDecmial != null) ? Helper.GetStoryPointInString(i.StoryPointsInDecmial.Value) : null);
}
}
}
catch (Exception ex)
{
}
return(result);
}
public List <StatausDetails> GetWorflowDetails(int statusId)
{
using (var context = new IssueTrackerEntities())
{
if (context.Database.Connection.State == ConnectionState.Closed)
{
context.Database.Connection.Open();
}
List <StatausDetails> WorkFlowStatus = (from workflow in context.WorkFlowStatus.Where(i => i.StatusId == statusId)
from status in context.Statuses.Where(s => s.StatusId == statusId)
select new StatausDetails
{
StatusId = workflow.StatusId,
StatusName = status.StatusName,
SortOrder = workflow.SortOrder
}).ToList();
return(WorkFlowStatus);
}
}
public void CreateProject(String Projectkey, String ProjectName, int ProjectLead)
{
var Entity = new IssueTrackerEntities();
using (var sa = new IssueTrackerEntities())
{
IssueTrackerBase.Data.Project pro = new IssueTrackerBase.Data.Project();
pro.ProjectKey = Projectkey;
pro.ProjectName = ProjectName;
pro.ProjectLeadUserId = ProjectLead;
pro.CreatedBy = 1;
pro.CreatedDate = DateTime.Now;
pro.ModifiedBy = 1;
pro.ModifiedDate = DateTime.Now;
sa.Projects.Add(pro);
sa.SaveChanges();
}
}
public ActionResult Login(UserModel model, string returnUrl)
{
if (ModelState.IsValid)
{
// Lets first check if the Model is valid or not
using (var entities = new IssueTrackerEntities())
{
string name = model.UserName;
string pass = model.Password;
// Now if our password was enctypted or hashed we would have done the
// same operation on the user entered password here, But for now
// since the password is in plain text lets just authenticate directly
bool userValid = entities.Users.Any(user => user.EmailId == name && user.Password == pass);
// User found in the database
if (userValid)
{
FormsAuthentication.SetAuthCookie(name, false);
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/") &&
!returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("GetAllAgileBoardDetails", "Agile"));
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public List <Components> ComponentList()
{
var Entity = new IssueTrackerEntities();
var ComponentsListData = from components in Entity.Components
join projects in Entity.Projects on components.ProjectId equals projects.ProjectId
join users in Entity.Users on components.LeadId equals users.UserId
where projects.IsActive == true && users.IsActive == true && components.IsActive == true
select new Components
{
ComponentName = components.ComponentName,
ProjectName = projects.ProjectName,
LeadName = users.DisplayName,
modifyDate = components.ModifiedDate
};
List <Components> component = ComponentsListData.ToList();
return(component);
}
public List <IssueListDetails> GetIssueList()
{
var TaskEntity = new IssueTrackerEntities();
var IssueDetailsData = (from IssueDetails in TaskEntity.IssueDetails
join components in TaskEntity.Components on IssueDetails.ComponentId equals components.ComponentId
join priorities in TaskEntity.Priorities on IssueDetails.PriorityId equals priorities.PriorityId
join IssueTypes in TaskEntity.IssueTypes on IssueDetails.IssueTypeId equals IssueTypes.IssueTypeId
join Statuses in TaskEntity.Statuses on IssueDetails.StatusId equals Statuses.StatusId
where IssueDetails.IsActive == true && components.IsActive == true && IssueTypes.IsActive == true && Statuses.IsActive == true && priorities.IsActive == 1
select new IssueListDetails
{
TaskId = IssueDetails.IssueId,
TaskIdName = IssueDetails.TaskId,
Title = IssueDetails.Title,
PriorityName = priorities.PriorityName,
ProjectStatus = Statuses.StatusName,
ComponentsName = components.ComponentName,
DueDate = IssueDetails.DueDate.ToString()
}).ToList();
return(IssueDetailsData);
}
