public ResultForm(int projectId)
{
matchedCount = 0;
InitializeComponent();
var worker = new ProjectWorker();
var currentAttentionRate = worker.LoadResultToGrid(projectId, expectedGrid, actualGrid);
BuildGraph();
// обраховуємо % емоцій що співпали
var totalCount = actualGrid.Rows.Count;
matchedPercent = matchedCount * 100 / totalCount;
// витягуємо з бази очікуваний % уваги
this.expectedAttentionRate = worker.GetAttentionRate(projectId);
// відображаєм в label
this.attentionRateLabel.Text = $@"{currentAttentionRate}%";
this.matchedEmotionRateLabel.Text = $@"{matchedPercent}%";
if (currentAttentionRate >= expectedAttentionRate && matchedPercent >= 100 - delta)
{
resolutionLabel.Text = @"This project is eligeable to proceed";
}
else
{
resolutionLabel.Text = @"Project does not meet minimum requirements";
resolutionLabel.ForeColor = Color.IndianRed;
}
}
public async Task <IActionResult> Edit(int id, [Bind("ProjectWorkerID,ProjectID,WorkerID,RolOfProjectID")] ProjectWorker projectWorker)
{
if (id != projectWorker.ProjectWorkerID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(projectWorker);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProjectWorkerExists(projectWorker.ProjectWorkerID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ProjectID"] = new SelectList(_context.Project, "ProjectID", "ProjectID", projectWorker.ProjectID);
ViewData["RolOfProjectID"] = new SelectList(_context.RolOfProject, "ID", "ID", projectWorker.RolOfProjectID);
ViewData["WorkerID"] = new SelectList(_context.Worker, "ID", "ID", projectWorker.WorkerID);
return(View(projectWorker));
}
public static List <string> GetProfiles(Project project, ToolWindowType toolWindowType)
{
if (toolWindowType == ToolWindowType.PluginTraceViewer)
{
return(null);
}
SpklConfig spklConfig = ConfigFile.GetSpklConfigFile(project);
string projectPath = ProjectWorker.GetProjectPath(project);
switch (toolWindowType)
{
case ToolWindowType.PluginDeployer:
return(GetConfigProfiles(projectPath, spklConfig.plugins));
case ToolWindowType.SolutionPackager:
return(GetConfigProfiles(projectPath, spklConfig.solutions));
case ToolWindowType.WebResourceDeployer:
return(GetConfigProfiles(projectPath, spklConfig.webresources));
default:
return(null);
}
}
private void SpklInstrument_OnClick(object sender, RoutedEventArgs e)
{
try
{
Overlay.ShowMessage(_dte, "Instrumenting...", vsStatusAnimation.vsStatusAnimationSync);
if (CrmAssemblyList.SelectedIndex == -1)
{
return;
}
var service = (IOrganizationService)ConnPane.CrmService.OrganizationServiceProxy;
var ctx = new OrganizationServiceContext(service);
Project project = ConnPane.SelectedProject;
ProjectWorker.BuildProject(project);
string path = Path.GetDirectoryName(project.FullName);
DownloadPluginMetadataTask downloadPluginMetadataTask = new DownloadPluginMetadataTask(ctx, new TraceLogger());
downloadPluginMetadataTask.Execute(path);
}
finally
{
Overlay.HideMessage(_dte, vsStatusAnimation.vsStatusAnimationSync);
}
}
public static SpklConfig GetSpklConfigFile(Project project, bool isRetry = false)
{
string projectPath = ProjectWorker.GetProjectPath(project);
string path = Path.Combine(projectPath, ExtensionConstants.SpklConfigFile);
try
{
SpklConfig spklConfig;
using (StreamReader file = File.OpenText(path))
{
JsonSerializer serializer = new JsonSerializer();
spklConfig = (SpklConfig)serializer.Deserialize(file, typeof(SpklConfig));
}
return(spklConfig);
}
catch (Exception ex)
{
ExceptionHandler.LogException(Logger, $"{Resource.ErrorMessage_UnableReadDeserializeConfig}: {path}", ex);
MessageBox.Show($"{Resource.ErrorMessage_UnableReadDeserializeConfig}: {path}");
if (!isRetry)
{
return(RecreateConfig(project, path));
}
throw;
}
}
/// <summary>Gets the existing or creates a new configuration file.</summary>
/// <param name="project">The project.</param>
/// <param name="isRetry">if set to <c>true</c> [is retry].</param>
/// <returns>Configuration file.</returns>
public static SpklConfig GetSpklConfigFile(Project project, bool isRetry = false)
{
var projectPath = ProjectWorker.GetProjectPath(project);
var path = Path.Combine(projectPath, ExtensionConstants.SpklConfigFile);
ExLogger.LogToFile(Logger, $"{Resource.Message_ReadingFile}: {path}", LogLevel.Info);
try
{
SpklConfig spklConfig;
using (var file = File.OpenText(path))
{
var serializer = new JsonSerializer();
spklConfig = (SpklConfig)serializer.Deserialize(file, typeof(SpklConfig));
}
return spklConfig;
}
catch (Exception ex)
{
ExceptionHandler.LogException(Logger, $"{Resource.ErrorMessage_UnableReadDeserializeConfig}: {path}", ex);
MessageBox.Show($"{Resource.ErrorMessage_UnableReadDeserializeConfig}: {path}");
if (!isRetry)
return RecreateConfig(project, path);
throw;
}
}
private void PostHandleCrmAssemblyProjects(Project project, IVsPackageInstaller installer)
{
try
{
project.DTE.SuppressUI = true;
//Install all the NuGet packages
project = (Project)((Array)_dte.ActiveSolutionProjects).GetValue(0);
NuGetProcessor.InstallPackage(installer, project, Resource.SdkAssemblyCore, _coreVersion);
if (_needsWorkflow)
{
NuGetProcessor.InstallPackage(installer, project, Resource.SdkAssemblyWorkflow, _coreVersion);
}
if (_needsClient)
{
NuGetProcessor.InstallPackage(installer, project, _clientPackage, _clientVersion);
}
ProjectWorker.ExcludeFolder(project, "bin");
ProjectWorker.ExcludeFolder(project, "performance");
if (_signAssembly)
{
Signing.GenerateKey(project, _destDirectory);
}
}
catch (Exception ex)
{
ExceptionHandler.LogException(Logger, Resource.ErrorMessage_ErrorProcessingTemplate, ex);
MessageBox.Show(Resource.ErrorMessage_ErrorProcessingTemplate);
}
}
public HttpResponseMessage Put([FromBody] ProjectWorker value)
{
if (ModelState.IsValid)
{
return((LogicProjectWorker.UpdateProjectWorker(value)) ?
new HttpResponseMessage(HttpStatusCode.OK) :
new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new ObjectContent <String>("Can not update in DB", new JsonMediaTypeFormatter())
});
}
;
List <string> ErrorList = new List <string>();
//if the code reached this part - the user is not valid
foreach (var item in ModelState.Values)
{
foreach (var err in item.Errors)
{
ErrorList.Add(err.ErrorMessage);
}
}
return(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new ObjectContent <List <string> >(ErrorList, new JsonMediaTypeFormatter())
});
}
public HttpResponseMessage InsertProjectWorker(ProjectWorker projectWorker)
{
var newObj = new ProjectWorker()
{
Id = Guid.NewGuid(),
ProjectCode = projectWorker.ProjectCode,
OrganizationCode = projectWorker.OrganizationCode,
TeamSysNo = projectWorker.TeamSysNo,
IDCardType = projectWorker.IDCardType,
IDCardNumber = projectWorker.IDCardNumber,
WorkTypeCode = projectWorker.WorkTypeCode,
CellPhone = projectWorker.CellPhone,
IssueCardTime = projectWorker.IssueCardTime,
EntryTime = projectWorker.EntryTime,
ExitTime = projectWorker.ExitTime,
CompleteCardTime = projectWorker.CompleteCardTime,
CardNumber = projectWorker.CardNumber,
CardType = projectWorker.CardType,
HasContract = projectWorker.HasContract,
ContractCode = projectWorker.ContractCode,
WorkerAccommodationType = projectWorker.WorkerAccommodationType,
WorkerRole = projectWorker.WorkerRole,
PayRollBankCardNumber = projectWorker.PayRollBankCardNumber,
PayRollBankName = projectWorker.PayRollBankName,
HasBuyInsurance = projectWorker.HasBuyInsurance
};
var result = _projectWorker.InsertProjectWorker(newObj);
if (result)
{
return(toJson(null, OperatingState.Success, "添加成功"));
}
return(toJson(null, OperatingState.Failure, "添加失败"));
}
public IResult Add(ProjectWorker projectWorkers)
{
var getWorkerDepartments = _workerDepartmentTypeService.GetByWorkerID(projectWorkers.WorkerID).Data;
var getDepartmentTypeInSection = _projectSectionDepartmentService.GetByID(projectWorkers.ProjectSectionDepartmentID).Data;
var getProjectSection = _projectSectionService.GetBySectionID(getDepartmentTypeInSection.ProjectSectionID).Data;
var getProject = _projectService.GetByID(getProjectSection.ProjectID).Data;
IResult result = BusinessRules.Run(CheckProjectWorkerCapacityIsFull(getProject), CheckIfWorkerHasDepartment(getWorkerDepartments, getDepartmentTypeInSection));
if (result != null)
{
return(result);
}
projectWorkers.Status = true;
_projectWorkerDal.Add(projectWorkers);
getProject.ActiveWorkerCount += 1;
var getProjectMapper = _mapper.Map <Project>(getProject);
_projectService.Update(getProjectMapper);
getProjectSection.WorkerCount += 1;
_projectSectionService.Update(getProjectSection);
return(new SuccessResult(Messages.ProjectWorkerAdded));
}
/// <summary>
/// Updatehours to user in project
/// </summary>
/// <param name="projectWorker">user in project</param>
/// <returns>bool</returns>
public static bool UpdateProjectHours(ProjectWorker projectWorker)
{
try
{
var httpWebRequest = (HttpWebRequest)WebRequest.Create($@"{GlobalProp.URI}api/updateProjectHours");
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "PUT";
using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
string cardsString = Newtonsoft.Json.JsonConvert.SerializeObject(projectWorker, Formatting.None);
streamWriter.Write(cardsString);
streamWriter.Flush();
streamWriter.Close();
}
var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
if (httpResponse.StatusDescription == "OK")
{
return(true);
}
else
{
return(false);
}
}
catch
{
return(false);
}
}
private void PostHandleWebResourceProjects(Project project)
{
//Turn off Build option in build configurations
SolutionConfigurations solutionConfigurations = _dte.Solution.SolutionBuild.SolutionConfigurations;
string folderProjectFileName = ProjectWorker.GetFolderProjectFileName(project.FullName);
SolutionWorker.SetBuildConfigurationOff(solutionConfigurations, folderProjectFileName);
}
public ActionResult DeleteConfirmed(int id)
{
ProjectWorker projectWorker = db.ProjectWorkers.Find(id);
db.ProjectWorkers.Remove(projectWorker);
db.SaveChanges();
return(RedirectToAction("Index"));
}
void CommitVersion()
{
// make sure everything is saved
SaveProject();
ProjectWorker worker = new ProjectWorker();
worker.CommitRevision(proj, currentRevision);
}
public ActionResult Update(ProjectWorker projectWorker)
{
var result = _projectWorkerService.Update(projectWorker);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
/// <summary>
/// Delete the ProjectWorker
/// </summary>
/// <param name="projectWorker"></param>
/// <returns></returns>
public bool DeleteProjectWorker(ProjectWorker projectWorker)
{
if (projectWorker == null)
{
throw new ArgumentException("projectWorker is null");
}
bool result = _projectWorker.Delete(projectWorker);
return(result);
}
private void PreHandleUnitTestProjects(Dictionary <string, string> replacementsDictionary)
{
var testProjectPicker = new TestProjectPicker();
var result = testProjectPicker.ShowModal();
if (!result.HasValue || result.Value == false)
{
throw new WizardBackoutException();
}
if (testProjectPicker.SelectedProject != null)
{
var solution = _dte.Solution;
var project = testProjectPicker.SelectedProject;
var path = string.Empty;
var projectPath = Path.GetDirectoryName(project.FullName);
var solutionPath = Path.GetDirectoryName(solution.FullName);
if (!string.IsNullOrEmpty(projectPath) && !string.IsNullOrEmpty(solutionPath))
{
if (projectPath.StartsWith(solutionPath))
{
path = "..\\" + project.UniqueName;
}
else
{
path = project.FullName;
}
}
ProjectDataHandler.AddOrUpdateReplacements("$referenceproject$", "True", ref replacementsDictionary);
ProjectDataHandler.AddOrUpdateReplacements("$projectPath$", path, ref replacementsDictionary);
ProjectDataHandler.AddOrUpdateReplacements("$projectId$", project.Kind, ref replacementsDictionary);
ProjectDataHandler.AddOrUpdateReplacements("$projectName$", project.Name, ref replacementsDictionary);
}
if (testProjectPicker.SelectedUnitTestFramework != null)
{
_unitTestFrameworkPackage = testProjectPicker.SelectedUnitTestFramework.NugetName;
ProjectDataHandler.AddOrUpdateReplacements("$useXrmToolingClientUsing$",
testProjectPicker.SelectedUnitTestFramework.CrmMajorVersion >= 8 ? "1" : "0", ref replacementsDictionary);
}
else
{
if (testProjectPicker.SelectedProject == null)
{
return;
}
var version = ProjectWorker.GetSdkCoreVersion(testProjectPicker.SelectedProject);
ProjectDataHandler.AddOrUpdateReplacements("$useXrmToolingClientUsing$",
Versioning.StringToVersion(version).Major >= 8 ? "1" : "0", ref replacementsDictionary);
}
}
/// <summary>
/// Insert the ProjectWorker
/// </summary>
/// <param name="projectWorker"></param>
/// <returns></returns>
public bool InsertProjectWorker(ProjectWorker projectWorker)
{
if (projectWorker == null)
{
throw new ArgumentNullException("projectWorker is null");
}
bool result = _projectWorker.Insert(projectWorker);
return(result);
}
/// <summary>
/// Updates the ProjectWorker
/// </summary>
/// <param name="projectWorker"></param>
/// <returns></returns>
public bool UpdateProjectWorker(ProjectWorker projectWorker)
{
if (projectWorker == null)
{
throw new ArgumentNullException("projectWorker is null");
}
bool result = _projectWorker.SingleUpdate(projectWorker);
return(result);
}
public ActionResult Edit([Bind(Include = "Id,Project_Id,Employee_Id")] ProjectWorker projectWorker)
{
if (ModelState.IsValid)
{
db.Entry(projectWorker).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Employee_Id = new SelectList(db.Employees, "Id", "FirstName", projectWorker.Employee_Id);
ViewBag.Project_Id = new SelectList(db.Projects, "Id", "Name", projectWorker.Project_Id);
return(View(projectWorker));
}
public HttpResponseMessage UpdateProjectTraining(ProjectWorker projectWorker)
{
if (projectWorker.Id == Guid.Empty)
{
return(toJson(null, OperatingState.Failure, "Id不能为空"));
}
var obj = _projectWorker.GetProjectWorkerById(projectWorker.Id);
if (projectWorker.ProjectCode == null)
{
projectWorker.ProjectCode = obj.ProjectCode;
}
if (projectWorker.OrganizationCode == null)
{
projectWorker.OrganizationCode = obj.OrganizationCode;
}
if (projectWorker.TeamSysNo == null)
{
projectWorker.TeamSysNo = obj.TeamSysNo;
}
if (projectWorker.IDCardType == null)
{
projectWorker.IDCardType = obj.IDCardType;
}
if (projectWorker.IDCardNumber == null)
{
projectWorker.IDCardNumber = obj.IDCardNumber;
}
if (projectWorker.WorkTypeCode == null)
{
projectWorker.WorkTypeCode = obj.WorkTypeCode;
}
if (projectWorker.ProjectCode == null)
{
projectWorker.ProjectCode = obj.ProjectCode;
}
if (projectWorker.WorkerRole == null)
{
projectWorker.WorkerRole = obj.WorkerRole;
}
var result = _projectWorker.UpdateProjectWorker(projectWorker);
if (result)
{
return(toJson(null, OperatingState.Success, "修改成功"));
}
return(toJson(null, OperatingState.Failure, "修改失败"));
}
// GET: ProjectWorkers/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProjectWorker projectWorker = db.ProjectWorkers.Find(id);
if (projectWorker == null)
{
return(HttpNotFound());
}
return(View(projectWorker));
}
private void PreHandleUnitTestProjects(Dictionary <string, string> replacementsDictionary)
{
var testProjectPicker = new TestProjectPicker();
bool?result = testProjectPicker.ShowModal();
if (testProjectPicker.SelectedProject != null)
{
//TODO: Why am I doing this?
Solution solution = _dte.Solution;
Project project = testProjectPicker.SelectedProject;
string path = string.Empty;
string projectPath = Path.GetDirectoryName(project.FullName);
string solutionPath = Path.GetDirectoryName(solution.FullName);
if (!string.IsNullOrEmpty(projectPath) && !string.IsNullOrEmpty(solutionPath))
{
if (projectPath.StartsWith(solutionPath))
{
path = "..\\" + project.UniqueName;
}
else
{
path = project.FullName;
}
}
replacementsDictionary["$referenceproject$"] = "True";
replacementsDictionary.Add("$projectPath$", path);
replacementsDictionary.Add("$projectId$", project.Kind);
replacementsDictionary.Add("$projectName$", project.Name);
}
if (testProjectPicker.SelectedUnitTestFramework != null)
{
_unitTestFrameworkPackage = testProjectPicker.SelectedUnitTestFramework.NugetName;
replacementsDictionary.Add("$useXrmToolingClientUsing$",
testProjectPicker.SelectedUnitTestFramework.CrmMajorVersion >= 8 ? "1" : "0");
}
else
{
if (testProjectPicker.SelectedProject == null)
{
return;
}
string version = ProjectWorker.GetSdkCoreVersion(testProjectPicker.SelectedProject);
replacementsDictionary.Add("$useXrmToolingClientUsing$",
Versioning.StringToVersion(version).Major >= 8 ? "1" : "0");
}
}
public async Task <IActionResult> Create([Bind("ProjectWorkerID,ProjectID,WorkerID,RolOfProjectID")] ProjectWorker projectWorker)
{
if (ModelState.IsValid)
{
_context.Add(projectWorker);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ProjectID"] = new SelectList(_context.Project, "ProjectID", "ProjectID", projectWorker.ProjectID);
ViewData["RolOfProjectID"] = new SelectList(_context.RolOfProject, "ID", "ID", projectWorker.RolOfProjectID);
ViewData["WorkerID"] = new SelectList(_context.Worker, "ID", "ID", projectWorker.WorkerID);
return(View(projectWorker));
}
public IResult Update(ProjectWorker projectWorkers)
{
var getWorkerDepartments = _workerDepartmentTypeService.GetByWorkerID(projectWorkers.WorkerID).Data;
var getDepartmentTypeInSection = _projectSectionDepartmentService.GetByID(projectWorkers.ProjectSectionDepartmentID).Data;
IResult result = BusinessRules.Run(CheckIfWorkerHasDepartment(getWorkerDepartments, getDepartmentTypeInSection));
if (result != null)
{
return(result);
}
_projectWorkerDal.Update(projectWorkers);
return(new SuccessResult(Messages.ProjectWorkerUpdated));
}
// GET: ProjectWorkers/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProjectWorker projectWorker = db.ProjectWorkers.Find(id);
if (projectWorker == null)
{
return(HttpNotFound());
}
ViewBag.Employee_Id = new SelectList(db.Employees, "Id", "FirstName", projectWorker.Employee_Id);
ViewBag.Project_Id = new SelectList(db.Projects, "Id", "Name", projectWorker.Project_Id);
return(View(projectWorker));
}
public HttpResponseMessage UpdateProjectHours([FromBody] ProjectWorker value)
{
ModelState.Remove("value.User.Password");
ModelState.Remove("value.User.ConfirmPassword");
ModelState.Remove("value.User.Email");
if (ModelState.IsValid)
{
return((LogicProjectWorker.UpdateProjectWorker(value)) ?
Request.CreateResponse(HttpStatusCode.OK, true) :
new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new ObjectContent <String>("Can not update in DB", new JsonMediaTypeFormatter())
});
}
;
return(Request.CreateResponse(HttpStatusCode.BadRequest, BaseLogic.GetErorList(ModelState.Values)));
}
private void PostHandleCrmAssemblyProjects(Project project, IVsPackageInstaller installer)
{
try
{
project.DTE.SuppressUI = true;
//Pre-2015 use .NET 4.0
if (Versioning.StringToVersion(_coreVersion).Major < 7)
{
project.Properties.Item("TargetFrameworkMoniker").Value = ".NETFramework,Version=v4.0";
}
//Plug-in & workflows use .NET 4.5.2
else if (_crmProjectType == ProjectType.Plugin || _crmProjectType == ProjectType.Workflow)
{
project.Properties.Item("TargetFrameworkMoniker").Value = ".NETFramework,Version=v4.5.2";
}
//Console v9+ use .NET 4.6.2 //TODO: Getting "Project Unavailable" message when finished but project builds fine
//else if (_crmProjectType == ProjectType.Console && Versioning.StringToVersion(_coreVersion).Major >= 9)
// project.Properties.Item("TargetFrameworkMoniker").Value = ".NETFramework,Version=v4.6.2";
//Install all the NuGet packages
project = (Project)((Array)_dte.ActiveSolutionProjects).GetValue(0);
NuGetProcessor.InstallPackage(installer, project, Resource.SdkAssemblyCore, _coreVersion);
if (_needsWorkflow)
{
NuGetProcessor.InstallPackage(installer, project, Resource.SdkAssemblyWorkflow, _coreVersion);
}
if (_needsClient)
{
NuGetProcessor.InstallPackage(installer, project, _clientPackage, _clientVersion);
}
ProjectWorker.ExcludeFolder(project, "bin");
ProjectWorker.ExcludeFolder(project, "performance");
if (_signAssembly)
{
Signing.GenerateKey(project, _destDirectory);
}
}
catch (Exception ex)
{
ExceptionHandler.LogException(Logger, Resource.ErrorMessage_ErrorProcessingTemplate, ex);
MessageBox.Show(Resource.ErrorMessage_ErrorProcessingTemplate);
}
}
private void Edit_hours(object sender, Telerik.WinControls.UI.GridViewCellEventArgs e)
{
decimal x = Decimal.Parse(dgv_projectHours.Rows[e.RowIndex].Cells["NumHoursForProject"].Value.ToString());
ProjectWorker projectWorker = new ProjectWorker()
{
UserId = (list_workers.SelectedItem.Tag as User).UserId, HoursForProject = x, ProjectId = tasks[e.RowIndex].ProjectId
};
if (TaskRequests.UpdateProjectHours(projectWorker))
{
BaseService.GetMessage("sucsess update hours", "succsess");
}
else
{
BaseService.GetMessage("failed to update hours", "error");
}
}
private void Edit_hours(object sender, DataGridViewCellEventArgs e)
{
decimal x = Decimal.Parse(dgv_projectHours.Rows[e.RowIndex].Cells["NumHoursForProject"].Value.ToString());
ProjectWorker projectWorker = new ProjectWorker()
{
UserId = (cmbx_workers.SelectedItem as User).UserId, HoursForProject = x, ProjectId = tasks[e.RowIndex].ProjectId
};
if (UserLogic.updateProjectHours(projectWorker))
{
MessageBox.Show("Success");
}
else
{
MessageBox.Show("ERROR!!");
}
}
