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);
}
