private static IWritable DrawProposalActions(Proposal proposal, User user) { List<IWritable> components = new List<IWritable>(); if ( proposal.Status == ProposalStatus.Created ) { if (user.Equals(proposal.User)) { components.Add(A(ResolveUri.ForEditProposal(proposal), "Edit")); } if (user.Role.Equals(Role.Administrator)) { components.Add(Form("post", ResolveUri.ForAcceptProposal(proposal), InputSubmit("Accept"))); } components.Add(Form("post", ResolveUri.ForRejectProposal(proposal), InputSubmit("Reject"))); } var elem = Div( "controls", "actions" , components.ToArray() ); return elem; }
public override void Handle(Proposal context, StateChangeInfo stateChangeInfo) { var comment = new Comment { Description = stateChangeInfo.Description, Reason = stateChangeInfo.Reason, Problem = context.Problem, Proposal = context, Unit = stateChangeInfo.UnitHandler, IsAccepted = stateChangeInfo.IsAccepted }; Comments.Add(comment); if(stateChangeInfo.IsAccepted) { IsCurrent = false; var newState = new ProposalAcceptedState(); newState.IsCurrent = true; context.States.Add(newState); context.Problem.Request(stateChangeInfo); } else { IsCurrent = false; var newState = new ProposalCancelState(); newState.IsCurrent = true; context.States.Add(newState); } }
public Proposal AddProposal(string projectUId, Proposal newProposal) { var client = ClientHelper.GetClient(authorizationService); HttpResponseMessage response = client.Post(Url("ProjectProposals/" + projectUId + "/"), new ObjectContent<Proposal>(newProposal, JsonMediaTypeFormatter.DefaultMediaType)); ClientHelper.HandleHTTPErrorCode(response); return response.Content.ReadAs<Proposal>(); }
// GET: Ticket public ActionResult Index(string Id) { var model = new Proposal(); model = _context.Proposal.Where(x => x.RecId.Equals(new Guid(Id))).Include(t => t.Ticket).FirstOrDefault(); return(View(model)); }
public ProposalRepository() { sqlcmd = SqlFactory.MSSQL(); prop = new Proposal(); propinfo = new ProposalInfo(); // ...MoreComing. }
public virtual void DeleteDocument(string proposalId, string docId) { Proposal proposal = proposalService.GetById(proposalId); ProposalDocument currentDoc = proposal.ProposalDocuments.FirstOrDefault(d => d.Id == docId); proposal.ProposalDocuments.Remove(currentDoc); proposalService.Save(); }
public void Register(Proposal proposal) { lock (LockObject) { proposals.Add(proposal); changed.Add(proposal); } }
public ActionResult DeleteConfirmed(int id) { Proposal proposal = db.Proposals.Find(id); db.Proposals.Remove(proposal); db.SaveChanges(); return(RedirectToAction("Index")); }
public void DeleteProposal(Proposal proposal) { if (proposal == null) { throw new ArgumentNullException(nameof(proposal)); } _context.Proposal.Remove(proposal); }
public override bool SectionEquals(Proposal x, Proposal y) => CompareKeyedCollections(x.PrivacyDataTypes, y.PrivacyDataTypes) && CompareKeyedCollections(x.PrivacyMotivations, y.PrivacyMotivations) && CompareKeyedCollections(x.PrivacyStorageLocations, y.PrivacyStorageLocations) && CompareKeyedCollections(x.PrivacyDataAccessors, y.PrivacyDataAccessors) && x.PrivacySecurityMeasures == y.PrivacySecurityMeasures && x.PrivacyDataDisposalTerm == y.PrivacyDataDisposalTerm && base.SectionEquals(x, y);
public int AddProposal(int conferanceId, Proposal proposal) { var conferance = conferanceRepository.GetById(conferanceId); conferance.Proposals.Add(proposal); conferanceRepository.AddOrUpdate(conferance); return(proposal.Id); }
protected override Task StoreAsync(PaymentSectionModel model, Proposal proposal) { proposal.PaymentSubjectCount = model.SubjectCount; proposal.PaymentAverageSubjectCost = model.AverageSubjectCost; proposal.PaymentMaxTotalCost = model.MaxTotalCost; return(base.StoreAsync(model, proposal)); }
public void CreateProposal(Proposal proposal) { if (proposal == null) { throw new ArgumentNullException(nameof(proposal)); } _context.Add(proposal); }
public void insertIntoDatabase() { Proposal p = (Proposal)TempData["AnotherDataSet"]; Debug.WriteLine("entered insert function"); Debug.WriteLine(p.Abstract); new ProposalRepository().InsertProposal(p); }
protected override Task LoadAsync(FundingSectionModel model, Proposal proposal) { model.ContactName = proposal.FundingContactName; model.ContactEmail = proposal.FundingContactEmail; model.FinancialCode = proposal.FinancialCode; return(base.LoadAsync(model, proposal)); }
public ProposalInfo GetProposalInfoByID(int ProposalID) { Proposal proposal = propRep.InflateProposalInfo(ProposalID); return(proposal.PropInfo); //Now Do Some Logic with Proposal! }
public void Proposal_AddSections() { var proposal = new Proposal("proposal"); var section = new Section("section"); proposal.Add(section); CollectionAssert.AreEqual(new[] { section }, proposal.Sections.ToArray()); }
protected override Task StoreAsync(FundingSectionModel model, Proposal proposal) { proposal.FundingContactName = model.ContactName; proposal.FundingContactEmail = model.ContactEmail; proposal.FinancialCode = model.FinancialCode; return(base.StoreAsync(model, proposal)); }
public Task <HttpWebResponse> SubmitAsync(SerialilzableWebRequest r) { var proposal = new Proposal <string, SerialilzableWebRequest>(r); var tcs = new TaskCompletionSource <HttpWebResponse>(); completions.Add(proposal.guid, tcs); return(this.ReplicateAsync(proposal, CancellationToken.None).ContinueWith(ant => { ant.Wait(); return tcs.Task; }).Unwrap()); }
private static void SetProposalStatus( Proposal proposal, ProposalStatus status ) { if( proposal.Status != ProposalStatus.Created ) { throw new InvalidOperationException(); } proposal.Status = status; }
//取消提案 public ActionResult Delete(int id) { Proposal proposal = db.Proposal.Find(id); db.Proposal.Remove(proposal); db.SaveChanges(); return(RedirectToAction("Browse_F")); }
public void Equality_Default() { var a = new Proposal(); var b = new Proposal(); Assert.AreEqual(a, b); Assert.AreEqual(a.GetHashCode(), b.GetHashCode()); }
private static void SetProposalStatus(Proposal proposal, ProposalStatus status) { if (proposal.Status != ProposalStatus.Created) { throw new InvalidOperationException(); } proposal.Status = status; }
public void Deveria_validar_corretamente_o_periodo_do_emprestimo(int months, bool expected, String because) { var proposal = new Proposal(Guid.NewGuid(), 0, months); var isValid = _loanMonthlyInStallmentsValidator.Validate(proposal); isValid.Should().Be(expected, because: because); }
public virtual bool SectionEquals(Proposal x, Proposal y) => x.ProjectId == y.ProjectId && NeedsApprovalBy(x).Any() == NeedsApprovalBy(y).Any() && x.Comments.SingleOrDefault(c => c.SectionId == Id)?.Content == y.Comments.SingleOrDefault(c => c.SectionId == Id)?.Content && CompareKeyedCollections(GetAssociatedApprovals(x), GetAssociatedApprovals(y), a => a.AuthorityRole, (ax, ay) => ax.AuthorityRole == ay.AuthorityRole && ax.Status == ay.Status && ax.ValidatedBy == ay.ValidatedBy);
public void CreateProposalObjectFromString(string proposal, string topic, int duration) { var expected = new Proposal(topic, duration); var actual = ProposalParser.GenerateProposal(proposal); Assert.Equal(expected.Topic, actual.Topic); Assert.Equal(expected.Duration, actual.Duration); }
public IEnumerable <ApprovalAuthorityRole> NeedsApprovalBy(Proposal proposal) { return(proposal.Approvals .Where(a => RequiredApprovalRoles.Contains(a.AuthorityRole)) .Where(a => a.Status != ApprovalStatus.Approved && a.Status != ApprovalStatus.NotApplicable) .Select(a => a.AuthorityRole) .ToList()); }
public ReadOnlyProposal(Proposal proposal) { this.ProposalNumber = proposal.ProposalNumber; this.InsuranceId = proposal.InsuranceId; this.InsuranceName = proposal.InsuranceName; this.Coverage = proposal.Coverage; this.NetPremium = proposal.NetPremium; }
public async Task <ISectionModel> LoadAsync(Proposal proposal) { var model = new TModel(); await LoadAsync(model, proposal); return(model); }
internal ContractSide(DateTime date, Proposal parent, SideController sideController) { SideController = sideController; Parent = parent; EntryType action = parent.IsEveneSide(this) ? parent.Action : Graph.SideKey.OppositeType(parent.Action); SideKey = Graph.SideKey.Get(date, action); SideController.Register(this); }
public void VerifyScheduling(string proposalId) { Proposal proposal = repository.ProposalOf(Id.FromExisting(proposalId)); proposal.VerifyScheduling(); repository.Save(proposal); }
public ActionResult Preview(FormModal formModal) { Proposal proposal = formModal.proposal; Institute i = (Institute)Session["Institute"]; proposal.P_id = new ProposalRepository().getProposalId(proposal); if (proposal.IA != null && proposal.End_sem_exam != null) { proposal.total = proposal.IA + proposal.End_sem_exam; } else { proposal.total = null; } proposal.Institute = i.Name; try { foreach (Department d in i.Departments) { if (d.D_id.ToString() == proposal.Dept) { proposal.Dept = d.Dname; if (proposal.Course == null) { continue; } foreach (Course c in d.Courses) { if (c.C_id.ToString() == proposal.Course) { proposal.Course = c.Cname; if (proposal.Semester == null) { continue; } //foreach(Semester s in c.Semesters) //{ // if(s.S_id == proposal.Semester) // { // proposal.Semester = s.S_id; // if(proposal.Sub_type == "1") // } // } //} } } } } } catch (Exception e) { Debug.WriteLine(e); } TempData["DataSet"] = proposal; return(View()); }
private Payload CreateTransactionCommonPayload(Proposal ccodeProposal, ByteString propResponsePayload, List <Endorsement> endrsements) { ChaincodeEndorsedAction chaincodeEndorsedAction = new ChaincodeEndorsedAction { ProposalResponsePayload = propResponsePayload }; chaincodeEndorsedAction.Endorsements.AddRange(endrsements); //ChaincodeActionPayload ChaincodeActionPayload chaincodeActionPayload = new ChaincodeActionPayload { Action = chaincodeEndorsedAction }; //We need to remove any transient fields - they are not part of what the peer uses to calculate hash. ChaincodeProposalPayload p = ChaincodeProposalPayload.Parser.ParseFrom(ccodeProposal.Payload); ChaincodeProposalPayload chaincodeProposalPayloadNoTrans = new ChaincodeProposalPayload { Input = p.Input }; chaincodeActionPayload.ChaincodeProposalPayload = chaincodeProposalPayloadNoTrans.ToByteString(); TransactionAction transactionAction = new TransactionAction(); Header header = Header.Parser.ParseFrom(ccodeProposal.Header); if (Config.Instance.ExtraLogLevel(10)) { if (null != diagnosticFileDumper) { StringBuilder sb = new StringBuilder(10000); sb.Append("transaction header bytes:" + header.ToByteString().ToHexString()); sb.Append("\n"); sb.Append("transaction header sig bytes:" + header.SignatureHeader.ToHexString()); logger.Trace("transaction header: " + diagnosticFileDumper.CreateDiagnosticFile(sb.ToString())); } } transactionAction.Header = header.SignatureHeader; if (Config.Instance.ExtraLogLevel(10)) { if (null != diagnosticFileDumper) { logger.Trace("transactionActionBuilder.setPayload: " + diagnosticFileDumper.CreateDiagnosticFile(chaincodeActionPayload.ToByteString().ToHexString())); } } transactionAction.Payload = chaincodeActionPayload.ToByteString(); //Transaction Transaction transaction = new Transaction(); transaction.Actions.Add(transactionAction); return(new Payload { Header = header, Data = transaction.ToByteString() }); }
public HttpResponseMessage Post(int Id, bool ArtistPost) { Proposal currProposal = _db.Proposal.FirstOrDefault(c => c.Id == Id); Models.Service service = _db.User.FirstOrDefault(c => c.UserId == WebSecurity.CurrentUserId).Services.FirstOrDefault(c => c.Provider == "facebook"); if (service != null) { FacebookAPI facebook = new FacebookAPI(service.Token); if (service != null && currProposal != null) { dynamic status; if (ArtistPost) { status = facebook.InsertToArtistFeed(currProposal, WebSecurity.CurrentUserId, System.Web.HttpContext.Current.Request.UrlReferrer.ToString()); } else { status = facebook.InsertToFeed(currProposal, WebSecurity.CurrentUserId, System.Web.HttpContext.Current.Request.UrlReferrer.ToString()); } if (status is int && status == 1) { return(Request.CreateResponse(HttpStatusCode.NotFound)); } else if (status is int && status == 2) { return(Request.CreateResponse(HttpStatusCode.BadGateway)); } else if (status is int && status == 3) { return(Request.CreateResponse(HttpStatusCode.BadRequest)); } else if (status is int && status == 4) { return(Request.CreateResponse(HttpStatusCode.Created)); } else { if (ArtistPost) { _api.AddOrUpdateFacebookArtistPost(currProposal.Id, WebSecurity.CurrentUserId, status["id"].ToString()); //saving post id from facebook } else { _api.AddOrUpdateFacebookPost(currProposal.Id, WebSecurity.CurrentUserId, status["id"].ToString()); } return(Request.CreateResponse(HttpStatusCode.Created)); } } } return(Request.CreateResponse(HttpStatusCode.BadRequest)); }
private void LoadProposalDataIntoForm(Proposal proposal) { var vm = _vm; vm.FormTitle = Localizer.Creationg_KgsChallenge; vm.RefusalCaption = Localizer.UnjoinChallenge; vm.CustomSquareSize = proposal.Rules.Size.ToString(); vm.SelectedRuleset = KgsHelpers.ConvertRuleset(proposal.Rules.Rules); vm.IsRankedGame = proposal.GameType == GameType.Ranked; vm.IsPubliclyListedGame = proposal.Global; string previousOpponent = vm.OpponentName; UpdateOpponentFromProposal(proposal.Players); foreach (var player in proposal.Players) { if (player.GetName() == Connections.Kgs.Username) { vm.SelectedColor = player.Role == Role.White ? Core.Game.StoneColor.White : Core.Game.StoneColor.Black; } else if (!String.IsNullOrEmpty(player.GetName())) { string opponent = player.GetNameAndRank(); this._opponentName = opponent; vm.OpponentName = opponent; if (player.Role == Role.White) { vm.SelectedColor = Core.Game.StoneColor.Black; } else if (player.Role == Role.Black) { vm.SelectedColor = Core.Game.StoneColor.White; } else { // Other roles don't affect color. } } } if (proposal.Nigiri) { vm.SelectedColor = Core.Game.StoneColor.None; } vm.Handicap = proposal.Rules.Handicap; vm.CompensationString = proposal.Rules.Komi.ToString(CultureInfo.InvariantCulture); vm.UseRecommendedKomi = false; if (previousOpponent != vm.OpponentName) { Sounds.ChallengerChanged.PlayAsync(); var tab = Mvx.Resolve <ITabProvider>().GetTabForViewModel(vm); if (tab != null) { tab.IsBlinking = true; } } UpdateTimeControlFromRules(proposal.Rules); }
public void DefaultValues() { var sut = new Proposal(); Assert.Null(sut.Name); Assert.False(sut.Relevance.HasValue); Assert.AreNotEqual(0, sut.GetHashCode()); Assert.AreNotEqual(1, sut.GetHashCode()); }
public ProposalForm( Proposal proposal ) : base("New Proposal", H1( Text( "New Show" ) ) , Form( HttpMethod.Post, ResolveUri.ForSubmitEditProposal() , InputHidden("proposal_id", proposal.Id.ToString()) , Label( "show_name", "Show Name:" ), InputText( "show_name", false, proposal.Show.Name ) , Label( "show_description", "Show Description:" ), InputText( "show_description", false, proposal.Show.Description ) , InputSubmit( "submit" ) )) { }
public ActionResult Edit(CurricularUnit model) { if (!ModelState.IsValid) return View(model); var prop = new Proposal(model, User.Identity.Name); RepositoryLocator.Get<long, Proposal>().Insert(prop); return RedirectToAction("Details", "Prop", new { Id = prop.Key }); }
public HttpResponse PostEditFucForm(string acr, IEnumerable<KeyValuePair<string, string>> content, IPrincipal principal) { // Criar uma unidade curricular, associada à proposta, com os valores recolhidos do formulário de edição. var uc = BuildCurricularUnitFromContent(content); // Criar a proposta de alteração de unidade curricular. var prop = new Proposal(uc, principal.Identity.Name); RepositoryLocator.Get<long, Proposal>().Insert(prop); return new HttpResponse(HttpStatusCode.SeeOther).WithHeader("Location", ResolveUri.For(prop)); }
public ProposalView(Proposal proposal, IPrincipal principal) : base("Proposta " + proposal.Key, new FucsView(proposal.Info), Form(HttpMethod.Post, ResolveUri.ForProposalCancel(proposal.Key), InputSubmit("Cancelar Proposta")), principal.IsInRole(Roles.Coordenador) ? Form(HttpMethod.Post, ResolveUri.ForProposalAccept(proposal.Key), InputSubmit("Aceitar Proposta")) : Text(""), proposal.Owner.Equals(principal.Identity.Name) ? Form(HttpMethod.Get, ResolveUri.ForEdit(proposal), InputSubmit("Editar Proposta")) : Text("")) { }
public ProposalView(Proposal proposal, User user) : base(TITLE, H2(Text(string.Format("Proposal #{0}", proposal.Id))) , H1(Text(string.Format("Created By: {0}", proposal.User.Identity.Name ) ) ) , H1(Text(string.Format("Status: {0}", proposal.Status.ToString()))) , H1(Text(string.Format("Show: {0}", proposal.Show.Name))) , H1(Text(string.Format("Description: {0}", proposal.Show.Description))) , Ul( SeasonsToUl(proposal.Show.Seasons) ) , DrawProposalActions(proposal, user)) { }
public void Add(Proposal proposal, string userId, int communityId) { var community = this.communities.All().FirstOrDefault(c => c.Id == communityId); var proposalToAdd = new Proposal() { Community = community, Description = proposal.Description, Title = proposal.Title, AuthorId = userId }; this.proposals.Add(proposalToAdd); this.proposals.SaveChanges(); }
// // GET: /Proposals/Create // Creates Proposal Form based on an existing Show public ActionResult Create( string show ) { if ( show == null ) { return View(); } Show showObj = ShowService.GetShowByName( show ); if ( showObj == null ) { return HttpNotFound(); } User user = UserRepo.GetByUsername( User.Identity.Name ); Proposal proposal = new Proposal { Show = showObj, User = user }; return View( proposal ); }
public ActionResult Create( Proposal proposal ) { try { User user = UserRepo.GetByUsername( User.Identity.Name ); Show show = ShowService.GetShowByName( proposal.Show.Name ); if ( show == null ) { show = new Show { Description = proposal.Show.Description, Name = proposal.Show.Name }; } var createdProposal = ProposalService.AddProposal( show, user ); return RedirectToAction( "Details", "Proposals", new { id = createdProposal.Id } ); } catch { return View(proposal); return new HttpStatusCodeResult( ( int ) HttpStatusCode.InternalServerError ); } }
public Proposal AddProposal(string projectUId, Proposal newProposal) { // verifies permission authorizationService.VerifyPermissionAtProject(projectUId, PermissionSets.SCRUM_MASTER); authorizationService.VerifyCanSeeProposalValues(); // get proposals project Project project = projectsService.GetProject(projectUId); // crete new proposal newProposal.CreateDate = DateTime.Now; newProposal.TemplateName = "default"; // sets proposal template String[] templates = GetProposalTemplates(); if (templates.Length > 0) { if(!templates.Contains("default")) newProposal.TemplateName = templates.OrderBy(t => t).ToArray()[0]; } // create hours costs if not exist at project RoleHourCost[] costs = proposalsRepository.GetHourCosts(projectUId); if (costs == null || costs.Length == 0) { // try to find a similar project Project similar = projectsService.GetLastSimilarProject(projectUId, true); proposalsRepository.CreateHourCosts(project, similar); } // include all backlog items at the proposal newProposal.Items = new List<ProposalItem>(); ICollection<BacklogItem> projectItems = backlogservice.GetCurrentBacklog(projectUId, (short) BacklogFiltersMode.ALL); foreach (BacklogItem item in projectItems) newProposal.Items.Add(new ProposalItem() { ProposalUId = newProposal.ProposalUId, BacklogItemUId = item.BacklogItemUId, Item = item }); // calcs total value newProposal.TotalValue = newProposal.CalcTotalPrice(costs); proposalsRepository.SaveProposal(newProposal); return newProposal; }
private void UpdateProposalItems(ScrumFactoryEntities context, Proposal proposal, Proposal oldProposal) { // get new items added at the proposal and the removed ones ProposalItem[] newItems = new ProposalItem[0]; if (proposal.Items != null) newItems = proposal.Items.Where(i => !oldProposal.Items.Any(oi => oi.BacklogItemUId == i.BacklogItemUId)).ToArray(); ProposalItem[] deletedItems = new ProposalItem[0]; if (oldProposal.Items != null) deletedItems = oldProposal.Items.Where(oi => !proposal.Items.Any(i => i.BacklogItemUId == oi.BacklogItemUId)).ToArray(); // add and delete proposal items foreach (ProposalItem item in newItems) context.ProposalItems.AddObject(item); foreach (ProposalItem item in deletedItems) context.ProposalItems.DeleteObject(item); }
//public virtual Unit UnitHandler { get; set; } public abstract void Handle(Proposal context, StateChangeInfo stateChangeInfo);
public static InvestigatorViewModel Create(IRepository repository, Proposal proposal) { Check.Require(repository != null, "Repository must be supplied"); Check.Require(proposal != null); var viewModel = new InvestigatorViewModel {Investigator = new Investigator(), Proposal = proposal}; return viewModel; }
private void ShowDetail(Proposal proposal) { if (!CanSeeProposals()) return; executor.StartBackgroundTask<Proposal>( () => { LoadCosts(); LoadProjectItems(); LoadProjectItemsGroups(); return proposalsService.GetProjectProposal(proposal.ProjectUId, proposal.ProposalUId); }, p => { ProposalViewModel.HourCosts = costs; ProposalViewModel.Proposal = p; ProposalViewModel.SetProjectItems(projectItems, groups); ProposalViewModel.Show(); }); }
private void AddProposal() { if (IsAddingProposal) return; if (!CanSeeProposals()) return; if (Project.Sprints == null) return; IsAddingProposal = true; Proposal newProposal = new Proposal(); newProposal.ProjectUId = Project.ProjectUId; newProposal.ProposalUId = Guid.NewGuid().ToString(); newProposal.Description = Project.Description; newProposal.ProposalName = Properties.Resources.Proposal; newProposal.ProposalStatus = (short)ProposalStatus.PROPOSAL_WAITING; newProposal.CreateDate = DateTime.Now; newProposal.CurrencySymbol = System.Threading.Thread.CurrentThread.CurrentCulture.NumberFormat.CurrencySymbol; newProposal.UseCalcPrice = true; newProposal.EstimatedStartDate = Project.FirstSprint.StartDate; newProposal.EstimatedEndDate = Project.LastSprint.EndDate; executor.StartBackgroundTask<Proposal>( () => { if (projectItems == null) LoadProjectItems(); return proposalsService.AddProposal(newProposal.ProjectUId, newProposal); }, p => { p.SetBacklogItems(projectItems); Proposals.Add(p); IsAddingProposal = false; ShowDetail(p); }); }
public ActionResult Edit(Proposal model) { if (!ModelState.IsValid) return View(model); Proposal proposal = RepositoryLocator.Get<long, Proposal>().GetById(model.Key); if (proposal == null) { TempData["exception"] = "Não existe nenhuma proposta com o identificador indicado."; return RedirectToAction("Index", "Prop"); } if (!proposal.State.Equals(AbstractEntity<long>.Status.Pending)) return new HttpStatusCodeResult(403, "It's not possible to edit a proposal that's already accepted or canceled."); if (!proposal.Owner.Equals(User.Identity.Name)) return new HttpStatusCodeResult(403, "You are not the owner of this proposal."); proposal.Info = model.Info; TempData["message"] = "Proposta editada com sucesso."; return RedirectToAction("Details", "Prop", new { Id = proposal.Key }); }
public static Proposal AddProposal( Show show, User user ) { Proposal newProposal = new Proposal { Show = show, User = user }; RepositoryLocator.Proposals.Add(newProposal); return newProposal; }
public void SaveProposal(Proposal proposal) { using (var context = new ScrumFactoryEntities(this.connectionString)) { Proposal oldProposal = GetProjectProposal(proposal.ProjectUId, proposal.ProposalUId); using (TransactionScope scope = new TransactionScope()) { // if its a new proposal if (oldProposal == null) { // proposals context.Proposals.AddObject(proposal); // items foreach (ProposalItem pitem in proposal.Items) context.ProposalItems.AddObject(pitem); // clauses if(proposal.Clauses!=null) { foreach (ProposalClause clause in proposal.Clauses) context.ProposalClauses.AddObject(clause); } } // if is an old one else { context.AttachTo("Proposals", oldProposal); context.ApplyCurrentValues<Proposal>("Proposals", proposal); // if is approving a proposal, adds its XAML document if (proposal.ProposalDocument != null) context.ProposalDocuments.AddObject(proposal.ProposalDocument); if (oldProposal.Items == null) oldProposal.Items = new List<ProposalItem>(); if (proposal.Items == null) proposal.Items = new List<ProposalItem>(); UpdateProposalItems(context, proposal, oldProposal); UpdateProposalClauses(context, proposal, oldProposal); UpdateProposalFixedCosts(context, proposal, oldProposal); } context.SaveChanges(); scope.Complete(); } } }
public void AddToProposals(Proposal proposal) { base.AddObject("Proposals", proposal); }
private void UpdateProposalFixedCosts(ScrumFactoryEntities context, Proposal proposal, Proposal oldProposal) { // make sure no proposal has null collections if (proposal.FixedCosts == null) proposal.FixedCosts = new List<ProposalFixedCost>(); if (oldProposal.FixedCosts == null) oldProposal.FixedCosts = new List<ProposalFixedCost>(); ProposalFixedCost[] newCosts = new ProposalFixedCost[0]; newCosts = proposal.FixedCosts.Where(i => !oldProposal.FixedCosts.Any(oi => oi.ProposalFixedCostUId == i.ProposalFixedCostUId)).ToArray(); ProposalFixedCost[] deletedCosts = new ProposalFixedCost[0]; deletedCosts = oldProposal.FixedCosts.Where(oi => !proposal.FixedCosts.Any(i => i.ProposalFixedCostUId == oi.ProposalFixedCostUId)).ToArray(); ProposalFixedCost[] updatedCosts = new ProposalFixedCost[0]; updatedCosts = proposal.FixedCosts.Where(oi => oldProposal.FixedCosts.Any(i => i.ProposalFixedCostUId == oi.ProposalFixedCostUId)).ToArray(); // add/update/delete proposal items foreach (ProposalFixedCost cost in newCosts) context.ProposalFixedCosts.AddObject(cost); foreach (ProposalFixedCost cost in deletedCosts) context.ProposalFixedCosts.DeleteObject(cost); foreach (ProposalFixedCost cost in updatedCosts) context.ApplyCurrentValues<ProposalFixedCost>("ProposalFixedCosts", cost); }
private void UpdateProposalClauses(ScrumFactoryEntities context, Proposal proposal, Proposal oldProposal) { while (oldProposal.Clauses.Count > 0) context.ProposalClauses.DeleteObject(oldProposal.Clauses.First()); foreach (ProposalClause clause in proposal.Clauses) context.ProposalClauses.AddObject(clause); }
public static Proposal CreateProposal(int ID, byte[] rowVersion, global::System.DateTime createDate, decimal price, decimal proposalDatePrice, int proposal_Asset, int supplier_Proposal, int proposal_Currency) { Proposal proposal = new Proposal(); proposal.Id = ID; proposal.RowVersion = rowVersion; proposal.CreateDate = createDate; proposal.Price = price; proposal.ProposalDatePrice = proposalDatePrice; proposal.Proposal_Asset = proposal_Asset; proposal.Supplier_Proposal = supplier_Proposal; proposal.Proposal_Currency = proposal_Currency; return proposal; }
private void CalcBacklogPrice() { Proposal proposal = new Proposal(); proposal.UseCalcPrice = true; BacklogPriceStr = Properties.Resources.Calculating; executor.StartBackgroundTask<RoleHourCost[]>(() => { return proposalsService.GetHourCosts(Project.ProjectUId); }, costs => { proposal.Items = new List<ProposalItem>(); var items = SelectedItems; if (items.Count == 0) items = this.Items; foreach (var itemVM in items) proposal.Items.Add(new ProposalItem() { ProposalUId = proposal.ProposalUId, BacklogItemUId = itemVM.Item.BacklogItemUId, Item = itemVM.Item }); // calcs total value proposal.TotalValue = proposal.CalcTotalPrice(costs); BacklogPriceStr = proposal.TotalValue.ToString("c"); ; }); }
private ActionResult RedirectCheck(InvestigatorController investigatorController, Proposal proposal, Investigator investigator, Guid proposalId, string action, bool extraCheck = true, string discriptor = "for") { if (proposal == null) { investigatorController.Message = string.Format(StaticValues.Message_NotFound, "Your proposal was"); return investigatorController.RedirectToAction<ErrorController>(a => a.Index()); } if (proposal.Email != CurrentUser.Identity.Name) { investigatorController.Message = string.Format(StaticValues.Message_NoAccess, "that"); return investigatorController.RedirectToAction<ErrorController>(a => a.Index()); } if (proposal.IsSubmitted) { investigatorController.Message = string.Format(StaticValues.Message_ProposalSubmitted, string.Format("{0} investigator {1}", action, discriptor), "proposal"); return investigatorController.RedirectToAction<ProposalController>(a => a.Details(proposalId)); } if (!proposal.CallForProposal.IsActive || proposal.CallForProposal.EndDate.Date < DateTime.Now.Date) { investigatorController.Message = string.Format(StaticValues.Message_ProposalNotActive, string.Format("Cannot {0} investigator", action)); return investigatorController.RedirectToAction<ProposalController>(a => a.Edit(proposalId)); } if (extraCheck) { if (investigator == null) { investigatorController.Message = string.Format(StaticValues.Message_NotFound, "Investigator"); return investigatorController.RedirectToAction<ProposalController>(a => a.Edit(proposalId)); } if (investigator.Proposal.Guid != proposalId) { investigatorController.Message = string.Format(StaticValues.Message_NoAccess, "that"); return investigatorController.RedirectToAction<ErrorController>(a => a.Index()); } } return null; }
void InsertGroup(uint index, MarketDataSnapshotFullRefresh.NoMDEntries group, SideController sideController) { MDEntryGroups[index] = new Proposal(group, this, GetDatePair(), sideController); }