public bool PlaceProject(ProjectContract project)
{
using (var db = new TimeManagerContext())
{
try
{
var existRecords = from p in db.Projects
where p.Name == project.Name
select p;
if (existRecords.Count() == 0)
{
db.Projects.Add(new Project {
Name = project.Name
});
db.SaveChanges();
}
else
{
return(false);
}
}
catch (Exception ex)
{
// throw new FaultException<string>
Console.WriteLine(ex.Message);
}
}
return(true);
}
public ActionResult CreateWordTestTwo(FormCollection collection)
{
var model = new ProjectContract();
WordTestTwo(model);
return(this.RefreshParent());
}
public override void SetModel(dynamic entity)
{
Projects data = (Projects)entity;
BindingFromModel(data, this);
ProjectContract.Query(data.Id);
if (data.SupplierTranscationItem.Any())
{
foreach (var row in data.SupplierTranscationItem)
{
SuppliersViewModel model = new SuppliersViewModel();
model.ProjectId = row.ProjectId;
model.PlaceofReceipt = row.PlaceofReceipt;
if (row.ManufacturersBussinessItems != null)
{
model.ManufacturersName = row.ManufacturersBussinessItems.Manufacturers.Name;
model.TicketPeriod = row.ManufacturersBussinessItems.TicketPeriod.Name;
model.MaterialCategories = row.ManufacturersBussinessItems.MaterialCategories.Name;
model.PaymentTypeName = row.ManufacturersBussinessItems.PaymentTypes.PaymentTypeName;
model.TranscationCategories = row.ManufacturersBussinessItems.TranscationCategories.Name;
}
model.SetModel(row.ManufacturersBussinessItems);
Suppliers.Add(model);
}
}
}
// Operate on Projects
public ProjectContract[] GetAllProjects()
{
ProjectContract[] projects = null;
using (var db = new TimeManagerContext())
{
try
{
var query = from p in db.Projects
orderby p.Name
select p;
projects = new ProjectContract[query.Count()];
int counter = 0;
foreach (var item in query)
{
projects[counter] = new ProjectContract {
ProjectId = item.ProjectId, Name = item.Name
};
counter++;
}
}
catch (Exception ex)
{
// throw new FaultException<string>
Console.WriteLine(ex.Message);
}
}
return(projects);
}
//public ActionResult Edit()
//{
// return this.RefreshParent();
//}
public ActionResult UploadFiles(int id)
{
UploadModel = this.IDKLManagerService.GetProjectContractInfo(id);
ProjectDocFile model = new ProjectDocFile();
model.ProjectNumber = UploadModel.ProjectNumber;
return(View(model));
}
public CreateProjectWork(ProjectRepository projectRepository, ProjectContract newData, int userId, DefaultUserProvider defaultUserProvider, IMapper mapper) : base(projectRepository)
{
m_projectRepository = projectRepository;
m_newData = newData;
m_userId = userId;
m_defaultUserProvider = defaultUserProvider;
m_mapper = mapper;
}
public ActionResult Edit(int id)
{
var model = new ProjectContract();
ViewData.Add("ProjectCategory", new SelectList(EnumHelper.GetItemValueList <EnumProjectCategory>(), "Key", "Value", model.ProjectCategory));
model = this.IDKLManagerService.GetProjectContractInfo(id);
return(View("Refer", model));
}
public long CreateProject(ProjectContract projectData)
{
var currentUserId = m_userManager.GetCurrentUserId();
var work = new CreateProjectWork(m_projectRepository, projectData, currentUserId);
var resultId = work.Execute();
return(resultId);
}
public static Project ToEntity(this ProjectContract projectContract)
{
return(new Project
{
Id = projectContract.Id,
Text = projectContract.Text,
Title = projectContract.Title,
GitLink = projectContract.GitLink
});
}
public ActionResult Edit(int id)
{
var user = this.AccountService.GetUser(this.LoginInfo.LoginName);
var model = new ProjectContract();
model = this.IDKLManagerService.GetProjectContractInfo(id);
model.PayRatioFirst = "50";
ViewData.Add("ProjectCategory", new SelectList(EnumHelper.GetItemValueList <EnumProjectCategory>(), "Key", "Value", model.ProjectCategory));
return(View(model));
}
public async Task CreateProject(ProjectContract contract, string ownerId)
{
var group = await GetGroup(contract.GroupId, ownerId);
if (group.Projects.Any(p => p.Name == contract.Name))
{
throw new NameAlreadyUsedException(contract.Name);
}
var project = _projectModelMapper.Map(contract);
await _repository.AddProject(project);
}
public ActionResult CreateWord(int id, FormCollection collection)
{
var model = new ProjectContract();
model = this.IDKLManagerService.GetProjectContractInfo(id);
if (model.ProjectCategory == 2)
{
if (collection["ContractType"] == "0")
{
WORD3(model);
}
if (collection["ContractType"] == "1")
{
WORD4(model);
}
}
if (model.ProjectCategory == 1)
{
if (collection["ContractType"] == "0")
{
WORD0(model);
}
if (collection["ContractType"] == "1")
{
WORD1(model);
}
if (collection["ContractType"] == "2")
{
WORD2(model);
}
}
if (model.ProjectCategory == 0)
{
if (collection["ContractType"] == "0")
{
WORD0(model);
}
if (collection["ContractType"] == "1")
{
WORD1(model);
}
if (collection["ContractType"] == "2")
{
WORD2(model);
}
if (collection["ContractType"] == "3")
{
WORD3(model);
}
}
return(this.RefreshParent());
}
public IActionResult CreateProject([FromBody] CreateProjectRequest request)
{
using (var client = GetRestClient())
{
var newProject = new ProjectContract
{
Name = request.Name
};
var newProjectId = client.CreateProject(newProject);
return(Json(newProjectId));
}
}
public override void SetModel(dynamic entity)
{
try
{
ProjectContract data = (ProjectContract)entity;
BindingFromModel(data, this);
}
catch (Exception ex)
{
setErrortoModel(this, ex);
}
}
public void TestProjectContractContains()
{
var sut = new PatService();
var projectContract = new ProjectContract
{
ProjectId = 13,
ContractType = "JSA",
CreatedBy = "UnitTest"
};
var list = sut.GetProjectContractsByProject(13);
Assert.IsTrue(list.Contains(projectContract));
}
public void TestProjectContractCreate()
{
var sut = new PatService();
var projectContract = new ProjectContract
{
ProjectId = 13,
ContractType = "JSA",
CreatedBy = "UnitTest"
};
var newId = sut.CreateProjectContract(projectContract);
Assert.IsTrue(newId > 0);
}
public override void Query()
{
if (controller == null)
{
return;
}
if (Id != Guid.Empty)
{
var result = controller.Query(p => p.Id == Id);
if (!result.HasError)
{
ProjectContract data = result.Result.Single();
BindingFromModel(data, this);
if (data.CreateUser != null)
{
CreateUser = data.CreateUser.UserName;
}
if (data.PromissoryNoteManagement.Any())
{
PromissoryNoteManagement.Clear();
foreach (var row in data.PromissoryNoteManagement)
{
PromissoryNoteManagementViewModel model = new PromissoryNoteManagementViewModel();
model.DoEvents();
model.SetModel(row);
PromissoryNoteManagement.Add(model);
}
}
if (data.ProcessingAtlas.Any())
{
ProcessingAtlas.Clear();
foreach (var row in data.ProcessingAtlas.OrderBy(o => o.Order).ToList())
{
ProcessingAtlasViewModel model = new ProcessingAtlasViewModel();
model.DoEvents();
model.SetModel(row);
ProcessingAtlas.Add(model);
}
}
}
}
}
public static ProjectContract ConvertToProjectContract(Project project)
{
if (project == null)
{
return(null);
}
ProjectContract contractProject = new ProjectContract()
{
ProjectID = project.ProjectID, UserID = project.UserID, SubCategoryID = project.SubCategoryID, Description = project.Description, AverageCost = project.AverageCost, StartDate = project.StartDate, EndDate = project.EndDate, Finished = project.Finished, FreelancerID = project.FreelancerID, Date = project.Date, Featured = project.Featured, Name = project.Name,
};
return(contractProject);
}
private void Sumbit(int id, ProjectContract project, HYZK.Account.Contract.User user, ProjectContract model)
{
var user1 = this.AccountService.GetUser(this.LoginInfo.LoginName);
var model1 = this.IDKLManagerService.GetProjectContractInfo(id);
model1.ProjectStatus = -2;
ProjectInfo project1 = new ProjectInfo();
project1.ProjectCategory = model1.ProjectCategory;
project1.ProjectNumber = model1.ProjectNumber;
project1.ProjectName = model1.ProjectName;
project1.CompaneName = model1.CompaneName;
project1.CompanyAddress = model1.CompanyAddress;
project1.CompanyContact = model1.CompanyContact;
project1.ContactTel = model1.ContactTel;
project1.ZipCode = model1.ZipCode;
project1.ProjectClosingDate = model1.ProjectClosingDate;
project1.CreateTime = DateTime.Now;
project1.ProjectStatus = 2;
project1.Area = model.Area;
project1.MakeOutAnInvoiceTime = DateTime.Now;
project1.Person = user.Name;
var nn = this.IDKLManagerService.SelectContractInfo(model.ProjectName);
project1.SignTime = nn.ContractDate;
project1.ProjectName = nn.ProjectName;
project1.ProjectNumber = nn.ProjectNumber;
var models = new TimeInstructions();
models.SignTime = project1.SignTime.ToString();
models.ProjectNumBer = project1.ProjectNumber;
models.ProjectName = project1.ProjectName;
models.Instructions = user1.LoginName + "项目已创建成功到质管部";
models.SignTime = project1.SignTime.ToLongDateString();
models.TimeNode = DateTime.Now;
this.IDKLManagerService.InsertTimeInstructions(models);
this.IDKLManagerService.AddProjectInfo(project1);
ProjectFile file = new ProjectFile();
file.ProjectNumber = project.ProjectNumber;
file.FilePath = "";
file.CreateTime = project.CreateTime;
this.IDKLManagerService.AddProjectFile(file);
this.IDKLManagerService.UpdateProjectContract(model1);
}
public async Task EditProject(ProjectContract contract, string userId)
{
var storageGroup = await GetGroup(contract.GroupId, userId);
if (storageGroup.Projects.Any(p => p.Name == contract.Name && p.Id != contract.Id))
{
throw new GroupsModelException(nameof(contract.Name));
}
var storageProject = await _repository.GetProject(contract.Id);
var modelProject = _projectModelMapper.Map(contract);
var updatedProject = storageProject.Update(modelProject);
await _repository.UpdateProject(updatedProject);
}
private static void AddItemToList(ICollection <ProjectContract> list, IDataRecord rdr)
{
var entity = new ProjectContract
{
Id = (int)rdr["Id"],
ProjectId = (int)rdr["ProjectId"],
ContractType = rdr["ContractType"] as string,
CreatedBy = rdr["CreatedBy"] as string,
CreatedOn = rdr["CreatedOn"] as DateTime? ?? default(DateTime),
UpdatedBy = rdr["UpdatedBy"] as string,
UpdatedOn = rdr["UpdatedOn"] as DateTime? ?? default(DateTime)
};
list.Add(entity);
}
public ActionResult WORD1(ProjectContract Model)
{
string strFileName = "";
// CreateContractTestingAndEvaluation cr = new CreateContractTestingAndEvaluation();
CreateContractHazardAssessment cr = new CreateContractHazardAssessment(Model);
List <string> appList = new List <string>();
appList = cr.CreateReportWord();
#region 判断报告生成运行状态
if (appList[0] == "1")
{
FileInfo fr = new FileInfo(appList[1]);
fr.Delete();
return(Back("合同生成失败"));
}
if (appList[0] == "2")
{
FileInfo fr = new FileInfo(appList[1]);
fr.Delete();
return(Back("合同生成失败"));
}
if (appList[0] == "3")
{
FileInfo fr = new FileInfo(appList[1]);
fr.Delete();
return(Back("合同生成失败"));
}
#endregion
strFileName = appList[1];
//报告下载
if (!string.IsNullOrEmpty(strFileName))
{
string fileNewName = strFileName.Substring(strFileName.LastIndexOf("\\") + 1);
Response.Clear();
Response.ContentType = "application/octet-stream";
Response.ContentEncoding = Encoding.UTF8;
Response.AppendHeader("Content-Disposition", "attachment;filename=" + System.Web.HttpUtility.UrlEncode(fileNewName, Encoding.UTF8));
Response.WriteFile(strFileName);
Response.End();
}
else
{
return(Back("下载报告失败"));
}
return(Back("成功"));
}
public override void SaveModel()
{
ProjectContract data = new ProjectContract();
CopyToModel(data, this);
if (data.CreateUserId == Guid.Empty)
{
data.CreateUserId = controller.GetCurrentLoginUser().Result.UserId;
}
if (PromissoryNoteManagement.Any())
{
foreach (PromissoryNoteManagementViewModel model in PromissoryNoteManagement)
{
PromissoryNoteManagement entity = new PromissoryNoteManagement();
CopyToModel(entity, model);
entity.ProjectContractId = data.Id;
data.PromissoryNoteManagement.Add(entity);
}
}
if (ProcessingAtlas.Any())
{
foreach (ProcessingAtlasViewModel model in ProcessingAtlas)
{
ProcessingAtlas entity = new ProcessingAtlas();
CopyToModel(entity, model);
entity.ProjectContractId = data.Id;
data.ProcessingAtlas.Add(entity);
}
}
var result = controller.CreateOrUpdate(data);
if (result.HasError)
{
Errors = result.Errors;
HasError = result.HasError;
}
Refresh();
}
public static UM_Project ToEntity(this ProjectContract contract)
{
if (contract == null)
{
return(null);
}
var entity = new UM_Project();
entity.DateChanged = contract.DateChanged;
entity.DateCreated = contract.DateCreated;
entity.DateDeleted = contract.DateDeleted;
entity.ID = contract.ID;
entity.Name = contract.Name;
return(entity);
}
public long CreateProject(ProjectContract project)
{
try
{
var projectId = Post <long>("project", project);
return(projectId);
}
catch (HttpRequestException e)
{
if (m_logger.IsErrorEnabled())
{
m_logger.LogError("{0} failed with {1}", GetCurrentMethod(), e);
}
throw;
}
}
public static ProjectContract ToContract(this UM_Project entity)
{
if (entity == null)
{
return(null);
}
var contract = new ProjectContract();
contract.DateChanged = entity.DateChanged;
contract.DateCreated = entity.DateCreated;
contract.DateDeleted = entity.DateDeleted;
contract.ID = entity.ID;
contract.Name = entity.Name;
contract.IsActive = entity.IsActive;
return(contract);
}
public void Add(ProjectContract entity)
{
var projectContract = entity;
Debug.Assert(projectContract != null, "projectContract != null");
using (var connection = new SqlConnection(DbConnection))
{
using (var command = new SqlCommand("PaProjectContractInsert", connection))
{
var sqlParams = new List <SqlParameter>();
SqlHelper.AddReturnPara("@return_value", sqlParams);
SqlHelper.AddIntPara(projectContract.ProjectId, "@ProjectId", sqlParams);
SqlHelper.AddVarcharPara(projectContract.ContractType, "@ContractType", sqlParams);
SqlHelper.AddVarcharPara(projectContract.CreatedBy, "@CreatedBy", sqlParams);
// Output parameters
var paramId = new SqlParameter("@Id", SqlDbType.Int)
{
Direction = ParameterDirection.InputOutput,
Value = 0
};
sqlParams.Add(paramId);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddRange(sqlParams.ToArray());
connection.Open();
command.ExecuteNonQuery();
if (((Int32)command.Parameters["@return_value"].Value) != 0)
{
return;
}
projectContract.Id = (int)paramId.Value;
}
}
}
public async Task <bool> Insert(ProjectContract projectContract)
{
try
{
var project = await _context.Projects
.FirstOrDefaultAsync(x => x.ProjectID == projectContract.Project.ProjectID);
if (project == null)
{
return(false);
}
projectContract.Project = project;
var employee = await _context.Employees
.FirstOrDefaultAsync(x => x.EmployeeID == projectContract.InternalSigner.EmployeeID);
if (employee == null)
{
return(false);
}
projectContract.InternalSigner = employee;
if (projectContract.SigningDate == null ||
string.IsNullOrWhiteSpace(projectContract.CompanySigner) ||
projectContract.ExpiryDate == null)
{
return(false);
}
await _context.ProjectContracts.AddAsync(projectContract);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Debug.WriteLine(">>>>>>>>> " + ex.Message);
return(false);
}
}
public ProjectContract GetProjectContractByProjectIDAndNormSetIDAndName(int ProjectID, int NormSetID, string CopyName)
{
ProjectContract list = null;
try
{
//using (var Context = new Cubicle_EntityEntities())
//{
// list = Context.ProjectContracts.Where(p => p.ProjectID == ProjectID && p.NormSetId == NormSetID && p.CopyName == CopyName).SingleOrDefault();
//}
}
catch (Exception ex)
{
//bool false = BusinessLogicExceptionHandler.HandleException(ref ex);
if (false)
{
throw ex;
}
}
return(list);
}
public override void SaveModel()
{
try
{
ProjectContractController controller = new ProjectContractController();
if (Items.Any())
{
foreach (var item in Items)
{
ProjectContract data = new ProjectContract();
CopyToModel(data, item);
data.ProjectId = item.ProjectId;
controller.CreateOrUpdate(data);
}
}
}
catch (Exception ex)
{
setErrortoModel(this, ex);
}
}
