public void Initialize()
{
var context = new Mock<IContextAware>();
var view = new Mock<IProjectView>();
{
view.SetupSet(v => v.Model = It.IsAny<ProjectModel>())
.Verifiable();
}
var parameter = new ProjectParameter(context.Object);
var projectLink = new Mock<ILinkToProjects>();
Func<string, IDisposable> func = s => new MockDisposable();
var command = new CloseProjectCommand(projectLink.Object, func);
var container = new Mock<IDependencyInjectionProxy>();
{
container.Setup(c => c.Resolve<IContextAware>())
.Returns(context.Object);
container.Setup(c => c.Resolve<CloseProjectCommand>())
.Returns(command);
}
var presenter = new ProjectPresenter(container.Object);
((IPresenter)presenter).Initialize(view.Object, parameter);
Assert.AreSame(view.Object, presenter.View);
Assert.AreSame(parameter, presenter.Parameter);
view.VerifySet(v => v.Model = It.IsAny<ProjectModel>(), Times.Once());
}
/// <summary>
/// Initializes a new instance of the <see cref="FrmXtraAccountingObjectDetail"/> class.
/// </summary>
public FrmAllProjectDetail()
{
InitializeComponent();
_projectPresenter = new ProjectPresenter(this);
_projectsPresenter = new ProjectsPresenter(this);
_banksPresenter = new BanksPresenter(this);
_accountingObjectsPresenter = new AccountingObjectsPresenter(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="FrmXtraAccountingObjectDetail"/> class.
/// </summary>
public FrmProjectDetail()
{
InitializeComponent();
_projectPresenter = new ProjectPresenter(this);
_projectsPresenter = new ProjectsPresenter(this);
//_banksPresenter = new BanksPresenter(this);
this.Load += new System.EventHandler(this.FrmXtraRegister_Load);
//_accountingObjectsPresenter = new AccountingObjectsPresenter(this);
}
public ProjectPresenter InitProjectPresenter()
{
MainForm view = MainPresenter.Instance.View;
ProjectPresenter presenter = ProjectPresenter.Instance;
presenter.View = view;
presenter.Init();
return(presenter);
}
public FClients(IClientService clientService, IContactService contactService, IProjectService projectService, FAddClient fAddClient, FaddProject faddProject, FUpdateProject fUpdateProject, FAddContact fAddContact, FUpdateContact fUpdateContact)
{
InitializeComponent();
clientPresenter = new ClientPresenter(this, clientService);
contactPresenter = new ContactPresenter(this, contactService);
projectPresenter = new ProjectPresenter(this, projectService);
FAddClient = fAddClient;
FaddProject = faddProject;
FUpdateProject = fUpdateProject;
FAddContact = fAddContact;
FUpdateContact = fUpdateContact;
}
public void AddNew()
{
mock.Mockery mockery = new mock.Mockery();
IProjectView mockView = this.GetMockView_AddNew(mockery);
ProjectPresenter p = new ProjectPresenter(mockView);
p.AddNew(null, null);
Assert.That(this.dv.CurrentMode, Is.EqualTo(DetailsViewMode.Insert),
"Details View should be in insert mode");
Assert.That(this.dv.Visible, Is.EqualTo(true),"Details View should be visible");
mockery.VerifyAllExpectationsHaveBeenMet();
}
public void ItemCommand_Edit()
{
mock.Mockery mockery = new mock.Mockery();
IProjectView mockView = (IProjectView)mockery.NewMock(typeof(IProjectView));
DetailsViewCommandEventArgs e = this.GetDetailsViewCommandEventArgs(UpdateType.Update);
// DetailsView dv = this.GetProjectDetails(UpdateType.Update);
mock.Expect.Exactly(2).On(mockView).GetProperty("DataPath").Will(mock.Return.Value(this._DataPath));
mock.Expect.Once.On(mockView).Method("DetailsFocus");
ProjectPresenter presenter = new ProjectPresenter(mockView);
presenter.ItemCommand(null, e);
mockery.VerifyAllExpectationsHaveBeenMet();
}
public ActionResult DeleteProjectPerson(ProjectPresenter presenter, string projectPersonId)
{
var projectPersonList = presenter.Project.ProjectPersons.FirstOrDefault(e => e.ApplicationEntityState != ApplicationEntityState.Deleted && e.PersonID == Convert.ToInt32(projectPersonId, CultureInfo.CurrentCulture));
if (projectPersonList != null)
{
if (projectPersonList.ProjectPersonID == default(int))
{
presenter.Project.ProjectPersons.Remove(projectPersonList);
}
else
{
projectPersonList.ApplicationEntityState = ApplicationEntityState.Deleted;
}
}
return this.PartialView("_StackHolderDetails", presenter);
}
public ProjectView()
{
_presenter = new ProjectPresenter(this);
}
/// <summary>
/// views the project details.
/// </summary>
/// <param name="presenter">The presenter.</param>
private void RetrieveHistory(ProjectPresenter presenter)
{
var historyListItems = this.projectService.RetrieveHistory(Convert.ToInt32(presenter.Project.ProjectID, CultureInfo.CurrentCulture));
if (historyListItems != null && historyListItems.Count > 0)
{
AssignHistoryItems(presenter, historyListItems);
}
}
/// <summary>
/// Assigns the estimation hour categories.
/// </summary>
/// <param name="presenter">The presenter.</param>
private static void AssignEstimationHourCategories(ProjectPresenter presenter)
{
(from estimationHour in presenter.Project.EstimatedHours
join estimationCategory in presenter.EstimationCategoryList on estimationHour.EstimationCategoryID equals estimationCategory.ID
select MapEstimationHour(estimationHour, estimationCategory)).ToList();
}
/// <summary>
/// Function to assign history items.
/// </summary>
/// <param name="presenter">Presenter details</param>
/// <param name="historyListItems">Item details</param>
private static void AssignHistoryItems(ProjectPresenter presenter, IDictionary<string, IEnumerable<HistoryListItem>> historyListItems)
{
if (historyListItems.ContainsKey(RiskKeyValue))
{
presenter.AssignRiskHistoryList(historyListItems[RiskKeyValue].ToList());
}
if (historyListItems.ContainsKey(CommentsKeyValue))
{
presenter.AssignCommentsHistoryList(historyListItems[CommentsKeyValue].ToList());
}
}
public ActionResult SubmitStackHolderDetails(ProjectPresenter presenter)
{
var stakeHolderList = new List<StackHolderInfo>();
if (presenter != null)
{
presenter.StackHolder.ModifiedByDeveloperID = SessionData.Instance.UserInfo.Developer.DeveloperID;
this.projectStakeHolderService.InsertOrUpdateStackHolder(presenter.StackHolder);
var list = this.projectStakeHolderService.RetrieveStackHolderList(SessionData.Instance.UserInfo.Developer.DeveloperID);
foreach (var item in list)
{
var stakeHolderData = new StackHolderInfo();
stakeHolderData.DeveloperID = item.StakeHolderID;
stakeHolderData.DeveloperName = item.FirstName;
stakeHolderList.Add(stakeHolderData);
}
}
return new JsonResult { Data = stakeHolderList, MaxJsonLength = int.MaxValue };
}
private static void ValidateProjectDetails(ProjectPresenter presenter)
{
var regFormatAlphanumeric = new Regex(RegularExpressionAlphanumeric);
if (!string.IsNullOrEmpty(presenter.Project.MailRecipient))
{
var regFormatEmail = new Regex(RegularExpressionEmail);
var regFormatEmailSeparation = new Regex(RegularExpressionEmailSeparated);
char[] delimiters = new[] { ',', ';', ' ' };
var splittedArray = presenter.Project.MailRecipient.Split(delimiters, StringSplitOptions.RemoveEmptyEntries);
foreach (var email in splittedArray)
{
if (!string.IsNullOrWhiteSpace(email))
{
if (!regFormatEmail.IsMatch(email.Trim()))
{
presenter.ValidationErrors.Add(Recipient, Resources.ErrorEmailValidStackHolder);
break;
}
}
}
if (!presenter.ValidationErrors.ContainsKey(Recipient))
{
if (!regFormatEmailSeparation.IsMatch(presenter.Project.MailRecipient))
{
presenter.ValidationErrors.Add(Recipient, Resources.ErrorEmailSeparator);
}
}
}
if (string.IsNullOrEmpty(presenter.Project.Name) || string.IsNullOrWhiteSpace(presenter.Project.Name))
{
presenter.ValidationErrors.Add(Name, Resources.NameErrorMessage);
}
else if (!regFormatAlphanumeric.IsMatch(presenter.Project.Name))
{
presenter.ValidationErrors.Add(Name, Resources.NameFormatErrorMessageAlphanumeric);
}
if (presenter.Project.Priority == 0)
{
presenter.ValidationErrors.Add(Priority, Resources.PriorityErrorNumberMessage);
}
if (presenter.Project.ClientID == default(int))
{
presenter.ValidationErrors.Add(Client, Resources.ClientErrorMessage);
}
if (presenter.Project.Status == default(byte))
{
presenter.ValidationErrors.Add(Status, Resources.StatusErrorMessage);
}
else if (presenter.Project.Status == CompletedStatus && !presenter.Project.EndDate.HasValue)
{
presenter.ValidationErrors.Add(EndDate, Resources.EndDateCompulsory);
}
if (presenter.Project.Status != PinelineStatus && !presenter.Project.StartDate.HasValue)
{
presenter.ValidationErrors.Add(StartDate, Resources.StartDateCompulsory);
}
if (presenter.Project.StartDate.HasValue && !presenter.Project.StartDate.Value.IsValidDatabaseDate())
{
presenter.ValidationErrors.Add(StartDate, Resources.StartDateInvalidErrorMessage);
}
if (presenter.Project.StartDate.HasValue && presenter.Project.EndDate.HasValue && presenter.Project.StartDate.Value > presenter.Project.EndDate.Value)
{
presenter.ValidationErrors.Add(EndDate, Resources.EndDateInvalidErrorMessage);
}
if (presenter.Project.CompletedPercent.HasValue && presenter.Project.CompletedPercent > MaxPercentageValue)
{
presenter.ValidationErrors.Add(PercentCompletion, Resources.PercentCompletionErrorMessage);
}
if (presenter.Project.PrimaryPOCDeveloperID == default(int))
{
presenter.ValidationErrors.Add(PrimaryPoc, Resources.PrimaryErrorMessage);
}
if (string.IsNullOrWhiteSpace(presenter.Project.SharepointLink))
{
presenter.ValidationErrors.Add(Repository, Resources.EmptyRepositoryErrorMessage);
}
if (presenter.Project.AtRiskFlag && string.IsNullOrWhiteSpace(presenter.Project.Risk))
{
presenter.ValidationErrors.Add(RiskData, Resources.RiskValue);
}
}
/// <summary>
/// updates project.
/// </summary>
/// <param name="projectId">The project identifier.</param>
/// <param name="includeInactive">The include inactive.</param>
/// <returns>
/// Add Edit project view
/// </returns>
public ActionResult Update(string projectId, string includeInactive)
{
this.AddBreadcrumbItem(Resources.ManageProject, Url.ProjectsAction());
this.AddBreadcrumbItem(Resources.EditProject, string.Empty);
ProjectPresenter presenter = new ProjectPresenter();
if (!string.IsNullOrEmpty(includeInactive))
{
presenter.IncludeInactive = Convert.ToBoolean(includeInactive, CultureInfo.CurrentCulture);
}
presenter.IsEdit = true;
this.AssignProjectDetails(presenter, projectId);
var projectPersons = this.projectStakeHolderService.RetrieveProjectPersonList(SessionData.Instance.UserInfo.Developer.DeveloperID).Where(p => p.ProjectID == presenter.Project.ProjectID).ToList();
this.AssignPersonsList(presenter, projectPersons);
this.RetrieveHistory(presenter);
presenter.AssignArtifacts(this.lookupService.RetrieveProjectArtifactList(presenter.Project.ProjectID, SessionData.Instance.UserInfo.Developer.DeveloperID));
presenter.OldRiskValue = presenter.Project.Risk;
int nodeIndex = 0;
var groupedList = presenter.Artifacts.OrderBy(a => a.Squence)
.GroupBy(u => u.FunctionalArea)
.Select(grp => new ArtifactFillListItem { FunctionalArea = grp.Key, Items = grp.ToList() })
.ToList();
groupedList.ForEach(g => { g.NodeIndex = nodeIndex; nodeIndex++; g.IsSelected = g.Items.All(i => i.IsSelected.Value); });
presenter.AssignArtifacts(groupedList);
this.AssignMailRecipients(presenter);
return this.View("InsertOrUpdate", presenter);
}
/// <summary>
/// view project.
/// </summary>
/// <param name="projectId">The project identifier.</param>
/// <returns>
/// View Edit project view
/// </returns>
public ActionResult ViewProject(string projectId)
{
this.AddBreadcrumbItem(Resources.ManageProject, Url.ProjectsAction());
this.AddBreadcrumbItem(Resources.ProjectDashboard, string.Empty);
ProjectPresenter presenter = new ProjectPresenter();
presenter.Project = this.projectService.RetrieveById(Convert.ToInt32(projectId, CultureInfo.CurrentCulture), SessionData.Instance.UserInfo.Developer.DeveloperID);
this.ViewProjectDetails(presenter);
this.RetrieveHistory(presenter);
presenter.AssignArtifacts(this.lookupService.RetrieveProjectArtifactList(presenter.Project.ProjectID, SessionData.Instance.UserInfo.Developer.DeveloperID).Where(g => g.IsSelected == true).ToList());
int nodeIndex = 0;
var groupedList = presenter.Artifacts.OrderBy(a => a.Squence)
.GroupBy(u => u.FunctionalArea)
.Select(grp => new ArtifactFillListItem { FunctionalArea = grp.Key, Items = grp.Where(g => g.IsSelected == true).ToList() })
.ToList();
groupedList.ForEach(g => { g.NodeIndex = nodeIndex; nodeIndex++; g.IsSelected = g.Items.All(i => i.IsSelected.Value); });
presenter.AssignArtifacts(groupedList);
return this.View("ViewProject", presenter);
}
/// <summary>
/// Maps the project list item to project person.
/// </summary>
/// <param name="projectPersonlistItem">The project person list item.</param>
/// <param name="presenter">The presenter.</param>
/// <returns>person detail</returns>
private ProjectPerson MapProjectListItemToProjectPerson(ProjectPersonListItem projectPersonlistItem, ProjectPresenter presenter)
{
ProjectPerson person = new ProjectPerson();
var selectedRole = projectPersonlistItem.RoleID.HasValue ? presenter.Roles.FirstOrDefault(e => e.ID == projectPersonlistItem.RoleID) : new LookupItem { ID = -1 };
person.Email = projectPersonlistItem.Email;
person.Skype = projectPersonlistItem.Skype;
person.ApplicationEntityState = ApplicationEntityState.Modified;
person.ModifiedByDeveloperID = projectPersonlistItem.ModifiedByDeveloperID;
person.ModifiedDate = DateTime.Now;
person.Name = projectPersonlistItem.Name;
person.PersonID = projectPersonlistItem.StakeHolderID;
person.PersonType = projectPersonlistItem.PersonType;
person.PointOfContactFlag = projectPersonlistItem.PointOfContactFlag;
person.ProjectID = projectPersonlistItem.ProjectID;
person.RoleID = selectedRole.ID;
person.RoleName = selectedRole.Name;
person.ProjectPersonID = projectPersonlistItem.ProjectPersonID;
this.MapDeveloperImage(projectPersonlistItem, person);
return person;
}
/// <summary>
/// inserts project.
/// </summary>
/// <returns>
/// Add Edit project view
/// </returns>
public ActionResult Insert()
{
this.AddBreadcrumbItem(Resources.ManageProject, Url.ProjectsAction());
this.AddBreadcrumbItem(Resources.AddProject, string.Empty);
ProjectPresenter presenter = new ProjectPresenter();
presenter.IsEdit = false;
presenter.Project = new Project();
this.AssignProjectDetails(presenter, null);
presenter.AssignArtifacts(this.lookupService.RetrieveProjectArtifactList(null, SessionData.Instance.UserInfo.Developer.DeveloperID));
int nodeIndex = 0;
var groupedList = presenter.Artifacts.OrderBy(a => a.Squence)
.GroupBy(u => u.FunctionalArea)
.Select(grp => new ArtifactFillListItem { FunctionalArea = grp.Key, Items = grp.ToList() })
.ToList();
groupedList.ForEach(g => { g.NodeIndex = nodeIndex; g.IsSelected = true; nodeIndex++; g.Items.ForEach(i => i.IsSelected = true); });
presenter.AssignArtifacts(groupedList);
this.AssignMailRecipients(presenter);
return this.View("InsertOrUpdate", presenter);
}
/// <summary>
/// Assigns the persons list.
/// </summary>
/// <param name="presenter">The presenter.</param>
/// <param name="projectPerson">The project person.</param>
private void AssignPersonsList(ProjectPresenter presenter, IList<ProjectPersonListItem> projectPerson)
{
projectPerson.ForEach(p => presenter.Project.ProjectPersons.Add(this.MapProjectListItemToProjectPerson(p, presenter)));
}
/// <summary>
/// Maps the onsite developer details.
/// </summary>
/// <param name="presenter">The presenter.</param>
/// <param name="selectedHolderType">Type of the selected holder.</param>
/// <param name="selectedPersonId">The selected person identifier.</param>
private void AssignOnsiteDeveloperDetails(ProjectPresenter presenter, string selectedHolderType, string selectedPersonId)
{
var projectPerson = presenter.Project.ProjectPersons.Where(a => a.PersonID == Convert.ToInt32(selectedPersonId) && a.PersonType == Persontype.OnSiteTeam).FirstOrDefault();
var selectedRole = presenter.Roles.FirstOrDefault(e => e.ID == presenter.Role.ID);
var developerItem = this.developerService.RetrieveById(Convert.ToInt32(selectedPersonId));
if (projectPerson != null)
{
UpdateOnsiteDeveloper(presenter, selectedPersonId, projectPerson, selectedRole, developerItem);
}
else
{
AddOnsiteDeveloper(presenter, selectedPersonId, projectPerson, selectedRole, developerItem);
}
}
/// <summary>
/// Maps the stack holder details.
/// </summary>
/// <param name="presenter">The presenter.</param>
/// <param name="selectedHolderType">Type of the selected holder.</param>
/// <param name="selectedPersonId">The selected person identifier.</param>
private void AssignStackHolderDetails(ProjectPresenter presenter, string selectedHolderType, string selectedPersonId)
{
var stackHolderItem = this.projectStakeHolderService.RetrieveStackHolderById(Convert.ToInt32(selectedPersonId));
var projectPerson = presenter.Project.ProjectPersons.Where(a => a.PersonID == Convert.ToInt32(selectedPersonId) && a.PersonType == Persontype.StakeHolder).FirstOrDefault();
var selectedRole = presenter.Roles.FirstOrDefault(e => e.ID == presenter.Role.ID);
if (projectPerson != null)
{
UpdateStackHolder(presenter, selectedPersonId, stackHolderItem, projectPerson, selectedRole);
}
else
{
AddStackHolder(presenter, selectedPersonId, stackHolderItem, projectPerson, selectedRole);
}
}
public ActionResult ValidateErrorDetails(ProjectPresenter presenter, string projectStatusId)
{
ModelState.Clear();
if (presenter != null)
{
if (presenter.Project.Status == 0 && projectStatusId != "undefined" && projectStatusId != string.Empty)
{
presenter.Project.Status = Convert.ToByte(projectStatusId);
}
ValidateProjectDetails(presenter);
var errors = this.projectService.Validate(presenter.Project).Where(error => !error.FieldName.Equals("Assignments")).ToList();
presenter.ValidationErrors.Append(errors);
}
return new JsonResult { Data = presenter, MaxJsonLength = int.MaxValue };
}
public ActionResult ValidateIsInactive(ProjectPresenter presenter)
{
ModelState.Clear();
if (presenter != null)
{
var errorList = this.projectService.Validate(presenter.Project);
var reslutErrorList = errorList.Where(error => error.FieldName.Equals("Assignments")).ToList();
if (reslutErrorList.Count > 0)
{
return this.Json("true");
}
}
return this.Json(string.Empty);
}
public ActionResult ValidateProjectPerson(ProjectPresenter presenter)
{
ModelState.Clear();
if (presenter != null)
{
var regFormatEmailCheck = new Regex(RegularExpressionEmail);
if (string.IsNullOrWhiteSpace(presenter.StackHolder.FirstName))
{
presenter.ValidationErrors.Add(FirstName, Resources.ErrorNameStackHolder);
}
if (string.IsNullOrWhiteSpace(presenter.StackHolder.Email))
{
presenter.ValidationErrors.Add(Email, Resources.ErrorEmailStackHolder);
}
else if (!regFormatEmailCheck.IsMatch(presenter.StackHolder.Email))
{
presenter.ValidationErrors.Add(Email, Resources.ErrorEmailValidStackHolder);
}
if (string.IsNullOrWhiteSpace(presenter.StackHolder.Skype))
{
presenter.ValidationErrors.Add(SkypeID, Resources.ErrorSkypeStackHolder);
}
var errors = this.projectStakeHolderService.ValidateStackHolder(presenter.StackHolder);
presenter.ValidationErrors.Append(errors);
}
return new JsonResult { Data = presenter, MaxJsonLength = int.MaxValue };
}
public ActionResult RetrievePersonRoleId(string developerId, ProjectPresenter presenter)
{
if (developerId != null && developerId != "undefined")
{
var list = this.developerService.RetrieveList(null, null, SessionData.Instance.UserInfo.Developer.DeveloperID);
var item = list.FirstOrDefault(i => i.DeveloperID == Convert.ToInt32(developerId));
if (item != null)
{
var selectedRoleID = item.RoleID;
return new JsonResult { Data = selectedRoleID };
}
}
return this.Json(string.Empty);
}
public ActionResult LoadStackHolder(string rowId, ProjectPresenter presenter)
{
presenter.AssignRoles(this.lookupService.RetrieveRoles(null, null, SessionData.Instance.UserInfo.Developer.DeveloperID));
if (rowId.Equals(Zero))
{
StackHolder s = new StackHolder();
}
else
{
var result = this.projectStakeHolderService.RetrieveStackHolderById(Convert.ToInt32(rowId));
presenter.StackHolder = result;
}
return this.PartialView("_StackHolderPopUp", presenter);
////var result = this.projectStakeHolderService.RetrieveStackHolderById(Convert.ToInt32(rowId));
////return new JsonResult { Data = result, MaxJsonLength = int.MaxValue };
}
public FrmXtraProjectDetail()
{
InitializeComponent();
_projectPresenter = new ProjectPresenter(this);
_projectsPresenter = new ProjectsPresenter(this);
}
/// <summary>
/// Decodes the raw text.
/// </summary>
/// <param name="presenter">The presenter.</param>
private static void DecodeRawText(ProjectPresenter presenter)
{
presenter.Project.Comments = !string.IsNullOrEmpty(presenter.Project.Comments) ? WebUtility.HtmlDecode(presenter.Project.Comments) : presenter.Project.Comments;
if (!presenter.Project.AtRiskFlag)
{
presenter.Project.Risk = WebUtility.HtmlDecode(presenter.OldRiskValue);
}
else
{
presenter.Project.Risk = !string.IsNullOrEmpty(presenter.Project.Risk) ? WebUtility.HtmlDecode(presenter.Project.Risk) : presenter.Project.Risk;
}
}
public ActionResult AddEstimationHour(ProjectPresenter presenter)
{
ModelState.Clear();
if (presenter != null)
{
var estimationCategory = presenter.EstimationCategory;
if (estimationCategory != null)
{
var selectedEstimationCategory = presenter.EstimationCategoryList.FirstOrDefault(e => e.ID == estimationCategory.ID);
if (selectedEstimationCategory != null)
{
estimationCategory.Name = presenter.EstimationCategoryList.FirstOrDefault(e => e.ID == estimationCategory.ID).Name;
var item = presenter.Project.EstimatedHours.Where(e => e.EstimationCategoryID == estimationCategory.ID).FirstOrDefault();
if (item == null)
{
presenter.Project.EstimatedHours.Add(new EstimatedHour
{
ApplicationEntityState = ApplicationEntityState.Added,
EstimationCategoryID = estimationCategory.ID,
EstimationCategoryName = estimationCategory.Name,
Hours = presenter.EstimationHour
});
}
else
{
item.Hours = presenter.EstimationHour;
item.ApplicationEntityState = item.EstimatedHoursID > 0 ? ApplicationEntityState.Modified : ApplicationEntityState.Added;
}
presenter.TotalEstimationHours = 0;
presenter.Project.EstimatedHours.ForEach(i => presenter.TotalEstimationHours = i.ApplicationEntityState != ApplicationEntityState.Deleted ? presenter.TotalEstimationHours + i.Hours.Value : presenter.TotalEstimationHours);
}
}
}
return this.PartialView("_EstimatedHours", presenter);
}
/// <summary>
/// Calculates the total estimation hours.
/// </summary>
/// <param name="presenter">The presenter.</param>
private static void CalculateTotalEstimationHours(ProjectPresenter presenter)
{
presenter.Project.EstimatedHours.ForEach(i => presenter.TotalEstimationHours = presenter.TotalEstimationHours + i.Hours.Value);
}
/// <summary>
/// Initializes a new instance of the <see cref="FrmXtraAccountingObjectDetail" /> class.
/// </summary>
public FrmTargetProgram()
{
InitializeComponent();
_projectPresenter = new ProjectPresenter(this);
_projectsPresenter = new ProjectsPresenter(this);
}
/// <summary>
/// Adds the onsite developer.
/// </summary>
/// <param name="presenter">The presenter.</param>
/// <param name="selectedPersonId">The selected person identifier.</param>
/// <param name="projectPerson">The project person.</param>
/// <param name="selectedRole">The selected role.</param>
/// <param name="developerItem">The developer item.</param>
private static void AddOnsiteDeveloper(ProjectPresenter presenter, string selectedPersonId, ProjectPerson projectPerson, LookupItem selectedRole, Developer developerItem)
{
projectPerson = new ProjectPerson();
projectPerson.PointOfContactFlag = presenter.PointContactFlag;
projectPerson.ProjectID = presenter.Project.ProjectID;
projectPerson.ModifiedByDeveloperID = SessionData.Instance.UserInfo.Developer.DeveloperID;
projectPerson.ModifiedDate = DateTime.Now;
projectPerson.Email = developerItem.Email;
projectPerson.Skype = developerItem.Skype;
projectPerson.RoleName = selectedRole.Name;
projectPerson.RoleID = selectedRole.ID;
projectPerson.Name = developerItem.Name;
projectPerson.PersonID = Convert.ToInt32(selectedPersonId, CultureInfo.CurrentCulture);
projectPerson.PersonType = Persontype.OnSiteTeam;
projectPerson.DeveloperImage = developerItem.LoginID.RetrieveDeveloperImageName();
projectPerson.ApplicationEntityState = ApplicationEntityState.Added;
presenter.Project.ProjectPersons.Add(projectPerson);
}
/// <summary>
/// Assigns the project details.
/// </summary>
/// <param name="presenter">The presenter.</param>
/// <param name="projectId">The project identifier.</param>
private void AssignProjectDetails(ProjectPresenter presenter, string projectId)
{
int? clientId = null;
int? primarydeveloperId = null;
int? secondarydeveloperId = null;
int? parentProjectId = null;
if (presenter.IsEdit)
{
presenter.Project = this.projectService.RetrieveById(Convert.ToInt32(projectId, CultureInfo.CurrentCulture), SessionData.Instance.UserInfo.Developer.DeveloperID);
clientId = presenter.Project.ClientID;
primarydeveloperId = presenter.Project.PrimaryPOCDeveloperID;
secondarydeveloperId = presenter.Project.SecondaryPOCDeveloperID;
parentProjectId = presenter.Project.ParentProjectID;
}
else
{
presenter.Project = new Project();
presenter.Project.Priority = this.projectService.RetrieveMaximumPriorityValue(SessionData.Instance.UserInfo.Developer.CompanyID.Value);
presenter.Project.IsClosed = false;
}
presenter.AssignClients(this.lookupService.RetrieveClients(clientId, false, SessionData.Instance.UserInfo.Developer.DeveloperID));
presenter.AssignProjectStatusList(this.lookupService.RetrieveProjectStatusList(SessionData.Instance.UserInfo.Developer.DeveloperID));
presenter.AssignPrimaryPointOfContacts(this.lookupService.RetrieveDevelopers(primarydeveloperId, false, SessionData.Instance.UserInfo.Developer.DeveloperID));
presenter.AssignSecondaryPointOfContacts(this.lookupService.RetrieveDevelopers(secondarydeveloperId, false, SessionData.Instance.UserInfo.Developer.DeveloperID));
presenter.AssignParentProjects(this.lookupService.RetrieveProjects(null, parentProjectId, false, false, SessionData.Instance.UserInfo.Developer.DeveloperID).Where(p => p.ProjectID != presenter.Project.ProjectID && p.ParentProjectID.HasValue == false).ToList());
presenter.ParentProjectList.ForEach(p => { p.ProjectName = p.ProjectFullName; });
presenter.AssignEstimationCategories(this.lookupService.RetrieveEstimationCategories(null, null, SessionData.Instance.UserInfo.Developer.DeveloperID));
presenter.AssignRoles(this.lookupService.RetrieveRoles(null, null, SessionData.Instance.UserInfo.Developer.DeveloperID));
AssignEstimationHourCategories(presenter);
CalculateTotalEstimationHours(presenter);
}
public ActionResult AddProjectPersons(ProjectPresenter presenter, string selectedHolderType, string selectedPersonId)
{
ModelState.Clear();
if (presenter != null)
{
var personType = (Persontype)Enum.Parse(typeof(Persontype), selectedHolderType);
if (presenter.PointContactFlag == true && presenter.Project.ProjectPersons.Count > 0)
{
presenter.Project.ProjectPersons.ForEach(item => item.PointOfContactFlag = false);
}
switch (personType)
{
case Persontype.StakeHolder:
this.AssignStackHolderDetails(presenter, selectedHolderType, selectedPersonId);
break;
case Persontype.OnSiteTeam:
this.AssignOnsiteDeveloperDetails(presenter, selectedHolderType, selectedPersonId);
break;
}
}
return this.PartialView("_StackHolderDetails", presenter);
}
/// <summary>
/// views the project details.
/// </summary>
/// <param name="presenter">The presenter.</param>
private void ViewProjectDetails(ProjectPresenter presenter)
{
if (presenter != null)
{
presenter.Project.ClientName = this.lookupService.RetrieveClients(presenter.Project.ClientID, false, SessionData.Instance.UserInfo.Developer.DeveloperID).FirstOrDefault(c => c.ID == presenter.Project.ClientID).Name;
presenter.Project.StatusTitle = this.lookupService.RetrieveProjectStatusList(SessionData.Instance.UserInfo.Developer.DeveloperID).FirstOrDefault(c => c.ID == presenter.Project.Status).Name;
if (presenter.Project.ParentProjectID.HasValue)
{
var parentProject = this.projectService.RetrieveById(presenter.Project.ParentProjectID.Value, SessionData.Instance.UserInfo.Developer.DeveloperID);
presenter.Project.ParentProjectName = parentProject != null ? parentProject.Name : string.Empty;
}
if (presenter.Project.SecondaryPOCDeveloperID.HasValue)
{
var secondaryDeveloper = this.developerService.RetrieveById(presenter.Project.SecondaryPOCDeveloperID.Value);
presenter.Project.SecondaryContactName = secondaryDeveloper != null ? secondaryDeveloper.Name : string.Empty;
}
var primaryDeveloepr = this.developerService.RetrieveById(presenter.Project.PrimaryPOCDeveloperID);
presenter.Project.PrimaryContactName = primaryDeveloepr != null ? primaryDeveloepr.Name : string.Empty;
presenter.AssignEstimationCategories(this.lookupService.RetrieveEstimationCategories(null, null, SessionData.Instance.UserInfo.Developer.DeveloperID));
AssignEstimationHourCategories(presenter);
CalculateTotalEstimationHours(presenter);
}
}
public ActionResult SubmitDetails(ProjectPresenter presenter, string projectStatusId)
{
ModelState.Clear();
if (presenter != null)
{
if (presenter.Project.Status == 0 && projectStatusId != "undefined" && projectStatusId != string.Empty)
{
presenter.Project.Status = Convert.ToByte(projectStatusId);
}
presenter.Project.MailRecipient = !string.IsNullOrEmpty(presenter.Project.MailRecipient) ? presenter.Project.MailRecipient.Trim().Trim(',') : presenter.Project.MailRecipient;
presenter.Project.CompanyID = SessionData.Instance.UserInfo.Developer.CompanyID;
DecodeRawText(presenter);
string shortName = presenter.Project.ShortName;
presenter.Project.ShortName = string.IsNullOrWhiteSpace(shortName) ? null : shortName.Trim();
this.projectService.InsertOrUpdate(presenter.Project, presenter.Artifacts.SelectMany(item => item.Items).ToList(), SessionData.Instance.UserInfo.Developer.DeveloperID);
}
return this.Json(string.Empty);
}
public ActionResult DeleteEstimationHour(ProjectPresenter presenter, string estimationCategoryId)
{
ModelState.Clear();
if (presenter != null)
{
var estimationHour = presenter.Project.EstimatedHours.FirstOrDefault(e => e.ApplicationEntityState != ApplicationEntityState.Deleted && e.EstimationCategoryID == Convert.ToInt32(estimationCategoryId, CultureInfo.CurrentCulture));
if (estimationHour != null)
{
if (estimationHour.ProjectID == default(int))
{
presenter.Project.EstimatedHours.Remove(estimationHour);
}
else
{
estimationHour.ApplicationEntityState = ApplicationEntityState.Deleted;
}
presenter.TotalEstimationHours = presenter.TotalEstimationHours - estimationHour.Hours.Value;
}
}
return this.PartialView("_EstimatedHours", presenter);
}
