public async Task <IActionResult> Update([FromBody] ProposalVM vm)
{
var getResult = await _bo.ReadAsync(vm.Id);
if (!getResult.Success)
{
return(InternalServerError(getResult.Exception));
}
var item = getResult.Result;
if (item == null)
{
return(NotFound());
}
if (vm.CompareToModel(item))
{
return(NotModified());
}
item = vm.ToProposal(item);
var updateResult = await _bo.UpdateAsync(item);
if (!updateResult.Success)
{
return(InternalServerError(updateResult.Exception));
}
return(Ok());
}
public async Task <IActionResult> Edit(Guid id, ProposalVM vm)
{
if (ModelState.IsValid)
{
var getOperation = await _bo.ReadAsync(id);
if (!getOperation.Success)
{
return(OperationErrorBackToIndex(getOperation.Exception));
}
if (getOperation.Result == null)
{
return(RecordNotFound());
}
var result = getOperation.Result;
if (!vm.CompareToModel(result))
{
result = vm.ToProposal(result);
var updateOperation = await _bo.UpdateAsync(result);
if (!updateOperation.Success)
{
TempData["Alert"] = AlertFactory.GenerateAlert(NotificationType.Danger, updateOperation.Exception);
return(View(vm));
}
return(OperationSuccess("The record was successfully updated."));
}
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Edit(Guid?id)
{
if (id == null)
{
return(RecordNotFound());
}
var getOperation = await _bo.ReadAsync((Guid)id);
if (!getOperation.Success)
{
return(OperationErrorBackToIndex(getOperation.Exception));
}
if (getOperation.Result == null)
{
return(RecordNotFound());
}
var vm = ProposalVM.Parse(getOperation.Result);
var listJobOperation = await _jobBO.ListUndeletedAsync();
if (!listJobOperation.Success)
{
return(OperationErrorBackToIndex(listJobOperation.Exception));
}
var jobList = new List <SelectListItem>();
foreach (var item in listJobOperation.Result)
{
var listItem = new SelectListItem()
{
Value = item.Id.ToString(), Text = (item.Address + " -- STARTING @ " + item.StartDate)
};
if (item.Id == vm.JobId)
{
listItem.Selected = true;
}
jobList.Add(listItem);
}
ViewBag.Jobs = jobList;
var crumbs = GetCrumbs();
crumbs.Add(new BreadCrumb()
{
Action = "Edit", Controller = "Proposals", Icon = "fa-edit", Text = "Edit"
});
ViewData["Title"] = "Edit proposal";
ViewData["BreadCrumbs"] = crumbs;
return(View(vm));
}
public ActionResult StudentProposal()
{
var model = new ProposalVM
{
AllProposalTypes = _unitOfWork.Proposals.GetAllProposalTypes(),
AllDegreeTypes = _unitOfWork.Departments.GetAllDegreeTypes()
};
return(View(model));
}
public async Task <IActionResult> CreateAsync([FromBody] ProposalVM vm)
{
var newProposal = vm.ToProposal();
var result = await _bo.CreateAsync(newProposal);
if (!result.Success)
{
return(InternalServerError(result.Exception));
}
return(Created(Request.Path.Value, null));
}
public async Task <IActionResult> New(ProposalVM vm)
{
if (ModelState.IsValid)
{
var model = vm.ToProposal();
var createOperation = await _bo.CreateAsync(model);
if (!createOperation.Success)
{
return(OperationErrorBackToIndex(createOperation.Exception));
}
return(OperationSuccess("The record was successfully created."));
}
return(View(vm));
}
public async Task <IActionResult> Details(Guid?id)
{
if (id == null)
{
return(RecordNotFound());
}
var getOperation = await _bo.ReadAsync((Guid)id);
if (!getOperation.Success)
{
return(OperationErrorBackToIndex(getOperation.Exception));
}
if (getOperation.Result == null)
{
return(RecordNotFound());
}
var getJobOperation = await _jobBO.ReadAsync(getOperation.Result.JobId);
if (!getJobOperation.Success)
{
return(OperationErrorBackToIndex(getJobOperation.Exception));
}
if (getJobOperation.Result == null)
{
return(RecordNotFound());
}
var vm = ProposalVM.Parse(getOperation.Result);
var crumbs = GetCrumbs();
crumbs.Add(new BreadCrumb()
{
Action = "Details", Controller = "Proposals", Icon = "fa-info-circle", Text = "Details"
});
ViewData["Title"] = "Proposal details";
ViewData["BreadCrumbs"] = crumbs;
ViewData["Job"] = JobVM.Parse(getJobOperation.Result);
return(View(vm));
}
public EstimateEditorVM(TECBid bid, ChangeWatcher watcher, TECEstimator estimate)
{
this.bid = bid;
this.watcher = watcher;
ScopeEditorVM = new ScopeEditorVM(bid, watcher);
LaborVM = new LaborVM(bid, estimate);
ReviewVM = new ReviewVM(bid, estimate);
ProposalVM = new ProposalVM(bid);
ItemizedSummaryVM = new ItemizedSummaryVM(bid, watcher);
MaterialSummaryVM = new MaterialSummaryVM(bid, watcher);
RiserVM = new RiserVM(bid, watcher);
ScheduleVM = new ScheduleVM(bid, watcher);
BidPropertiesVM = new BidPropertiesVM(bid);
InternalNotesVM = new InternalNotesVM(bid);
QuotesVM = new QuotesVM(bid, watcher);
RefreshMaterialSummaryCommand = new RelayCommand(executeMaterialRefersh);
}
public async Task <IActionResult> GetAsync(Guid id)
{
var getResult = await _bo.ReadAsync(id);
if (!getResult.Success)
{
return(InternalServerError(getResult.Exception));
}
var item = getResult.Result;
if (item == null)
{
return(NotFound());
}
var vm = ProposalVM.Parse(item);
return(Ok(vm));
}
public async Task <IActionResult> ListAsync()
{
var listResult = await _bo.ListUndeletedAsync();
if (!listResult.Success)
{
return(InternalServerError(listResult.Exception));
}
var list = listResult.Result;
var finalList = new List <ProposalVM>();
foreach (var item in list)
{
var vm = ProposalVM.Parse(item);
finalList.Add(vm);
}
return(Ok(finalList));
}
public ActionResult ProposalIndex(int?page, Int64?providerId, string vl, string prm = null)
{
TempData["providerId"] = providerId;
ProposalVM proposalVM = new ProposalVM();
ProposalRepository proposalRepository = new ProposalRepository();
try
{
Search search = new Search();
search = SetValue(page, vl, prm);
search.ProviderID = (Int64)providerId;
int pageSize = 15;
int pageNumber = (page ?? 1);
proposalVM.Search = search;
proposalVM.Search.pageSize = pageSize;
proposalVM.Search.pageNumber = pageNumber;
proposalVM.ProviderID = search.ProviderID;
proposalVM.RProposalList = proposalRepository.SW_GePropsals(proposalVM.Search);
proposalVM.ListCount = proposalRepository.SW_GePropsalssCount(proposalVM.Search);
int[] pc = new int[proposalVM.ListCount];
proposalVM.Paging = pc.ToPagedList(pageNumber, pageSize);
// viewModel.vehicleId = vehicleId;
return(Request.IsAjaxRequest()
? (ActionResult)PartialView("ProposalPartialIndex", proposalVM)
: View(proposalVM));
}
catch (Exception ex)
{
return(View("Error", new HandleErrorInfo(ex, "Error", "Error")));
}
}
public async Task <IActionResult> Index()
{
var listOperation = await _bo.ListUndeletedAsync();
if (!listOperation.Success)
{
return(OperationErrorBackToIndex(listOperation.Exception));
}
var finalList = new List <ProposalVM>();
foreach (var item in listOperation.Result)
{
finalList.Add(ProposalVM.Parse(item));
}
var jobList = await GetJobViewModels(listOperation.Result.Select(x => x.JobId).Distinct().ToList());
ViewData["Title"] = "Proposals";
ViewData["Jobs"] = jobList;
ViewData["BreadCrumbs"] = GetCrumbs();
ViewData["DeleteHref"] = GetDeleteRef();
return(View(finalList));
}
public async Task <IActionResult> Create(ProposalView model)
{
ViewBag.Success = "";
ViewBag.Error = "";
var errors = new List <string>();
if (model.InvoiceItems == null || model.InvoiceItems.Count() == 0)
{
errors.Add("Add atleast one Item !");
}
//if(!ModelState.IsValid)return View(model);
if (model.CreateNew)
{
if (model.IsCompany)
{
if (string.IsNullOrEmpty(model.Partner.Name))
{
errors.Add("Enter Company Name !");
}
}
else
{
model.Partner.Name = model.PersonName;
if (string.IsNullOrEmpty(model.PersonName))
{
errors.Add("Enter Person Name !");
}
}
if (string.IsNullOrEmpty(model.Partner.EmailId) && string.IsNullOrEmpty(model.Partner.MobileNo))
{
errors.Add("Enter Phone Number or Email !");
}
}
else
{
if (model.IsCompany)
{
if (model.SelectedCompanyId == 0)
{
errors.Add("Select Company !");
}
}
else
{
if (model.SelectedPersonId == 0)
{
errors.Add("Select Person !");
}
}
}
//if (string.IsNullOrEmpty(model.Description)) errors.Add("Enter Description !");
if (errors.Count > 0)
{
var errorMessage = "";
errors.ForEach(err => errorMessage += err + "<br />");
ViewBag.Error = errorMessage;
return(View(model));
}
else
{
model.Items = JsonConvert.DeserializeObject <List <ProposalItems> >(model.InvoiceItems);
//if (model.Partner == null) model.Partner = new BusinessPartner();
if (model.SelectedCompanyId > 0 || model.SelectedPersonId > 0)
{
model.Partner = new BusinessPartner()
{
Name = "Name"
}
}
;
//if (string.IsNullOrEmpty(model.PersonName)) model.PersonName = "";
if (string.IsNullOrEmpty(model.Contact.Name))
{
model.Contact.Name = "Name";
}
var newProposalVM = new ProposalVM()
{
ContactMode = model.ContactMode,
CreateNew = model.CreateNew,
Description = model.Description,
IsCompany = model.IsCompany,
Partner = model.Partner,
PersonName = model.PersonName,
SelectedCompanyId = model.SelectedCompanyId,
SelectedPersonId = model.SelectedPersonId,
SelectedContactId = model.SelectedContactId,
NewContact = model.Contact,
Items = model.Items,
Discount = model.Discount,
VAT = (DateTime.Today < July01_2020)?(byte)5:(byte)15
};
var apiModel = new APIEmpIdModel <ProposalVM>();
apiModel.EmployeeId = int.Parse(User.Claims.Single(c => c.Type == "userid").Value);
apiModel.Model = newProposalVM;
var result = await api.Post <APIEmpIdModel <ProposalVM>, int>("Proposals/", apiModel);
if (result > 0)
{
//ViewBag.Success = "Proposal Saved";
//ModelState.Clear();
//return View(new Proposal());
return(RedirectToAction("List2"));
}
else
{
ViewBag.Error = "Error saving Proposal";
return(View(model));
}
}
}
public async Task <ActionResult> StudentProposal(ProposalPostVM vm)
{
var ReturnMoodel = new ProposalVM()
{
AllProposalTypes = _unitOfWork.Proposals.GetAllProposalTypes(),
AllDegreeTypes = _unitOfWork.Departments.GetAllDegreeTypes()
};
if (!vm.ProposalType.Value.Equals("Thesis"))
{
ModelState["FirstName"].Errors.Clear();
ModelState["LastName"].Errors.Clear();
ModelState["Email"].Errors.Clear();
ModelState["Company"].Errors.Clear();
}
if (ModelState.IsValid)
{
//////////Create List of Contirbutors in the ticket
var _Contributors = new List <Contributor>();
var student = UserManager.FindByName(User.Identity.Name);
var StudentRoleInTicket = db.Roles.Where(x => x.Name.Equals("Student")).FirstOrDefault();
var FirstSupervisor = UserManager.FindById(vm.FirstSupervisor.Key);
var FirstSuperVisorRole = db.Roles.Where(x => x.Name.Equals("Supervisor")).FirstOrDefault();
_Contributors.Add(new Contributor()
{
User = student, RoleInTicket = StudentRoleInTicket, Status = "Approved"
});
_Contributors.Add(new Contributor()
{
User = FirstSupervisor, RoleInTicket = FirstSuperVisorRole, Status = "Approved"
});
ApplicationUser SecondSupervisor;
ApplicationRole SecondSuperVisorRole;
//If The Proposal is for Thesis than Second Supervisor Should be Assigned.
if (vm.ProposalType.Value.Equals("Thesis"))
{
//If Supervisor is not external and from university than assign it directly
if (!vm.SecondSupervisor.Key.Equals("ExternalSupervisor"))
{
SecondSupervisor = UserManager.FindById(vm.SecondSupervisor.Key);
SecondSuperVisorRole = db.Roles.Where(x => x.Name.Equals("SecondSupervisor")).FirstOrDefault();
_Contributors.Add(new Contributor()
{
User = SecondSupervisor, RoleInTicket = SecondSuperVisorRole, Status = "Approved"
});
}
//If Supervisor is not from University and also not already registered
else
{
var externalUser = new ApplicationUser
{
UserName = vm.ExternalSupervisor.Email,
Email = vm.ExternalSupervisor.Email,
FirstName = vm.ExternalSupervisor.LastName,
LastName = vm.ExternalSupervisor.LastName,
IsExternal = true
};
var result = UserManager.Create(externalUser);
//Error normally occors if supervisory is already there
if (!result.Succeeded)
{
ModelState.AddModelError("", "The Second Supervisor you are trying to add already exist select it from Second supervisor list" + result.Errors);
return(View(ReturnMoodel));
}
SecondSupervisor = UserManager.FindByEmail(vm.ExternalSupervisor.Email);
SecondSuperVisorRole = db.Roles.Where(x => x.Name.Equals("SecondSupervisor")).FirstOrDefault();
_Contributors.Add(new Contributor()
{
User = SecondSupervisor, RoleInTicket = SecondSuperVisorRole, Status = "Approval Pending"
});
}
}
//Contirbutors are created now
var NewTicket = new Ticket()
{
Title = vm.Name,
TicketType = "Degree",
Status = new List <TicketStatus>()
{
new TicketStatus()
{
Status = "Proposal Submitted"
}
},
Contributors = _Contributors
};
// NewTicket.Contributors.Add()
var NewProposal = new Proposal()
{
Name = vm.Name,
FirstSupervisor = UserManager.FindById(vm.FirstSupervisor.Key),
SecondSupervisor = vm.SecondSupervisor.Key == null ? null : UserManager.FindById(vm.SecondSupervisor.Key),
ProposalContent = new ProposalContent()
{
Content = vm.ProposalContent.Content
},
CreatedBy = UserManager.FindByName(User.Identity.Name),
Ticket = NewTicket
};
//Rest of the virtual links are assigned here to avoid creation of new records
NewProposal.ProposalType = _unitOfWork.Proposals.GetProposalTypeById(new Guid(vm.ProposalType.Key));
NewProposal.DegreeType = _unitOfWork.Departments.GetDegreeTypeById(new Guid(vm.DegreeType.Key));
NewProposal.DegreeProgram = _unitOfWork.Departments.GetDegreeProgramByID(new Guid(vm.DegreeProgram.Key));
NewProposal.Specializations = _unitOfWork.Departments.GetSpecializationById(new Guid(vm.Specilizations.Key));
NewProposal.ProposalStatus.Add(new ProposalStatus()
{
Status = "Proposal Submitted"
});
NewProposal.Ticket = NewTicket;
db.Ticket.Add(NewTicket);
db.Proposal.Add(NewProposal);
db.SaveChanges();
// //var result = _unitOfWork.Proposals.SubmitProposal(ToBeAdded);
// //_unitOfWork.Complete();
return(RedirectToAction("Index"));
//ViewBag.Message = "Models were Correct";
//return PartialView("UserInfoPopUp");
}
else
{
return(View(ReturnMoodel));
}
//ViewBag.Message = "Your Proposal Submitted Successfully";
//return RedirectToAction("UserInfoPopUp");
}
