private void WriteAssignments(Contract contract, IndentedTextWriter writer)
 {
     foreach (Member member in contract.Members)
     {
         writer.WriteLine("{0} = {1};", member.Name, GeneratorUtil.ParameterCase(member.Name));
     }
 }

        public static bool EditContract(Contract Ct)
        {
            try
            {
                db = new UcasProEntities();
                db.Configuration.LazyLoadingEnabled = false;
                db.Configuration.ProxyCreationEnabled = false;
                var q = db.Contracts.Where(p => p.ID == Ct.ID).SingleOrDefault();
                q.Employee_ID = Ct.Employee_ID;
                q.TotalSalary = Ct.TotalSalary;
                q.SelaryAmount = Ct.SelaryAmount;
                q.StartDate = Ct.StartDate;
                q.EndDate = Ct.EndDate;
                q.Status = Ct.Status;
                
                db.SaveChanges();
                return true;

            }
            catch (Exception ex)
            {


                Xprema.XpremaException e = new Xprema.XpremaException();
                e.CodeNumber = 6;
                e.OtherDescription = ex.InnerException.InnerException.Message;
                e.UserDescription = "Error in Save Changed";
                e.UserDescriptionArabic = "خطاء في حفظ البيانات";
                throw e;
            }
        }

        public Contract.Search.SearchResultCollection ExecuteClientSearch(Contract.Search.Search search)
        {
            YellowstonePathology.YpiConnect.Service.SearchGateway gateway = new YellowstonePathology.YpiConnect.Service.SearchGateway();
            YellowstonePathology.YpiConnect.Contract.Search.SearchResultCollection searchResults = null;

            switch (search.SearchType)
            {
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.PatientLastNameSearch:
                    searchResults = gateway.GetClientCasesByPatientLastName(search);
                    break;
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.PatientLastAndFirstNameSearch:
                    searchResults = gateway.GetClientCasesByPatientLastNameAndFirstName(search);
                    break;
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.RecentCases:
                    searchResults = gateway.GetClientRecentCases(search);
                    break;
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.NotDownloaded: //Not Downloaded is Depricated SH 5/17/2010
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.NotAcknowledged:
                    searchResults = gateway.GetClientCasesNotAcknowledged(search);
                    break;
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.DateOfBirth:
                    searchResults = gateway.GetClientCasesByPBirthDate(search);
                    break;
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.SocialSecurityNumber:
                    searchResults = gateway.GetClientCasesByPSSN(search);
                    break;
            }

            if (searchResults == null) searchResults = new Contract.Search.SearchResultCollection();
            return searchResults;
        }

 public override void Initialize(BacktestServerProxy.RobotContext grobotContext, 
     Contract.Util.BL.CurrentProtectedContext protectedContextx)
 {
     base.Initialize(grobotContext, protectedContextx);
     packers = Graphics.ToDictionary(g => g.a, g => new CandlePacker(g.b));
     digitsDen = (int) Math.Pow(10, roundDigits);
 }

 public void InsertTest(Contract.CTestManager manager)
 {
     using (TestManagerDBContainer container = new TestManagerDBContainer())
     {
         int result = container.InsertTestManager(manager.Name, manager.Description, manager.NumberOfQuestions, manager.NumberOfQuestions, manager.TotalMarks, manager.GradeID, manager.Duration, manager.PassingMarks);
     }
 }

        public static bool NewContract(Contract Ct)
        {
            try
            {
                db = new UcasProEntities();
                db.Configuration.ProxyCreationEnabled = false;
                db.Configuration.LazyLoadingEnabled = false;
                db.Contracts.Add(Ct);
                db.SaveChanges();
                return true;

            }
            catch (Exception ex)
            {
               
                Xprema.XpremaException e = new Xprema.XpremaException();
                e.CodeNumber = 6;
                e.OtherDescription = ex.InnerException.InnerException.Message;
                File.WriteAllText("t.txt", ex.InnerException.InnerException.Message);
                e.UserDescription = "Error in Save Changed";
                if (ex.InnerException.InnerException.Message.Contains("Violation of PRIMARY KEY constraint 'PK_Contracts'. Cannot insert duplicate key in object 'dbo.Contracts'"))
                {
                    e.UserDescriptionArabic = "الموظف موجود عقده في المشروع مسبقا";

                }
                else
                    e.UserDescriptionArabic = e.OtherDescription;//"خطاء في اضافة البيانات";
               
                 throw e;
            }
        }

        public Contract.Search.SearchResultCollection ExecutePathologistSearch(Contract.Search.Search search)
        {
            YellowstonePathology.YpiConnect.Service.SearchGateway gateway = new YellowstonePathology.YpiConnect.Service.SearchGateway();
            YellowstonePathology.YpiConnect.Contract.Search.SearchResultCollection searchResults = null;

            switch (search.SearchType)
            {
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.PatientLastNameSearch:
                    searchResults = gateway.GetPathologistCasesByPatientLastName(search);
                    break;
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.PatientLastAndFirstNameSearch:
                    searchResults = gateway.GetPathologistCasesByPatientLastNameAndFirstName(search);
                    break;
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.RecentCases:
                    searchResults = gateway.GetPathologistRecentCases(search);
                    break;
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.DateOfBirth:
                    searchResults = gateway.GetPathologistCasesByPBirthDate(search);
                    break;
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.SocialSecurityNumber:
                    searchResults = gateway.GetPathologistCasesByPSSN(search);
                    break;
                case YellowstonePathology.YpiConnect.Contract.Search.SearchTypeEnum.RecentCasesForFacilityId:
                    searchResults = gateway.GetRecentProfessionalCasesByFacilityId(search);
                    break;
            }

            if (searchResults == null) searchResults = new Contract.Search.SearchResultCollection();
            return searchResults;
        }

 /// <summary>
 /// Constructor for the <c>ReadGraph</c> object. This is used
 /// to create graphs that are used for reading objects from the XML
 /// document. The specified strategy is used to acquire the names
 /// of the special attributes used during the serialization.
 /// </summary>
 /// <param name="contract">
 /// this is the name scheme used by the strategy
 /// </param>
 /// <param name="loader">
 /// this is the class loader to used for the graph
 /// </param>
 public ReadGraph(Contract contract, Loader loader) {
    this.refer = contract.getReference();
    this.mark = contract.getIdentity();
    this.length = contract.getLength();
    this.label = contract.getLabel();
    this.loader = loader;
 }

        public bool ProvisionSiteCollection(Contract.SharePointProvisioningData sharePointProvisioningData)
        {
            bool processed = false;
            try
            {
                SiteProvisioningBase siteToProvision = null;
                switch (sharePointProvisioningData.Template)
                {
                    case SiteProvisioningTypes.ContosoCollaboration:
                        siteToProvision = new ContosoCollaboration();
                        break;
                    case SiteProvisioningTypes.ContosoProject:
                        siteToProvision = new ContosoProject();
                        break;
                }

                siteToProvision.SharePointProvisioningData = sharePointProvisioningData;
                HookupAuthentication(siteToProvision);

                // Hookup class that will hold the on-prem overrides
                SiteProvisioningOnPremises spo = new SiteProvisioningOnPremises();
                siteToProvision.SiteProvisioningOnPremises = spo;

                // Provision the site collection
                processed = siteToProvision.Execute();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                //log error
            }

            return processed;
        }

 private void btnNewContract_Click_1(object sender, RoutedEventArgs e)
 {
     Contract nContract = new Contract();
     nContract.CompanyId = company.Id;
     saveUpdateContract(nContract);
     loadContracts();
 }

        public async Task CreateContract(CreateContractInputDto input)
        {
            //We can use Logger, it's defined in ApplicationService class.
            Logger.Info("Creating an contract for input: " + input);

            //Creating a new Task entity with given input's properties
            var contract = new Contract
            {
                Start = input.Start,
                State = ContractState.Active,
                Type = input.Type,
                BaseHourQtyPerMonth = input.BaseHourQtyPerMonth,
                BaseHourRatePerMonth = input.BaseHourRatePerMonth
                

            };
            if (input.Finish.HasValue) { contract.Finish = input.Finish; }

            
            contract.AccountId = input.AccountId;
            contract.Account = _accountRepository.Load((long)input.AccountId);
           

            //Saving entity with standard Insert method of repositories.
            await _contractRepository.InsertAsync(contract);
        }

        public async Task<IHttpActionResult> PutContract(int id, Contract contract)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != contract.Id)
            {
                return BadRequest();
            }
            using (var transaction = db.Database.BeginTransaction())
            {
                var origin = db.Contracts.Find(contract.Id);
                db.Entry<Contract>(origin).Collection(c => c.AppartmentOwners).Load();

                db.Changes.AddRange(Helper.Logger.ChangeRecords<Contract>(origin, contract, RequestContext.Principal.Identity.Name));
                var added = contract.AppartmentOwners.Except(origin.AppartmentOwners.ToList(), new AppartmentOwnerComparator());
                var deleted = origin.AppartmentOwners.ToList().Except(contract.AppartmentOwners, new AppartmentOwnerComparator());
                db.AppartmentOwners.RemoveRange(deleted);
                foreach (var ao in added)
                {
                    ao.ContractId = contract.Id;
                    db.AppartmentOwners.Add(ao);
                }
                db.Entry<Contract>(origin).State = EntityState.Detached;
                await db.SaveChangesAsync();
                foreach (var ao in contract.AppartmentOwners)
                {
                    var aoindb = db.AppartmentOwners.Find(ao.Id);
                    aoindb.ShowAsOwner = ao.ShowAsOwner;
                    aoindb.ShowOnCert = ao.ShowOnCert;
                    db.Entry<AppartmentOwner>(aoindb).State = EntityState.Modified;
                }
               
                contract.AppartmentOwners = null;
                db.Entry<Contract>(contract).State = EntityState.Modified;
               
                try
                {
                    await db.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ContractExists(id))
                    {
                        return NotFound();
                    }
                    else
                    {
                        throw;
                    }
                }
                transaction.Commit();
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

        public ContractView(Contract contract)
        {
            InitializeComponent();

            _activeContract = contract;
            _repository = new DataRepository();

            PopulateFields(contract);
            InitializeHandlers();
        }

        public int PutUserProfile(Contract.DataContract.User user)
        {
            Guid userId = ((NotenetIdentity)HttpContext.Current.User.Identity).UID;
            if (userId != user.userID)
            {
                return -1;//will not be stopped at exception
            }

            return (int)db.PutUserInfo(user.userID, user.Birthday, user.NickName, user.RealName, user.Email).FirstOrDefault();
        }

        public DevContract(winStatusEnum status, Contract con = null)
        {
            InitializeComponent();
            if (con != null)
                m_contract = con;
            else
                m_contract = new Contract();

            SetFormStatus(status);
        }

 public ActionResult Edit(Contract contract)
 {
     if (ModelState.IsValid)
     {
         db.Entry(contract).State = EntityState.Modified;
         db.SaveChanges();
         return RedirectToAction("Index");
     }
     return View(contract);
 }

 public void Check(Contract contract)
 {
     for (int i = 0; i < ScriptHashes.Length; i++)
     {
         if (ScriptHashes[i] == contract.ScriptHash)
         {
             completed[i] = contract.IsCompleted(signatures[i].Keys.ToArray());
             break;
         }
     }
 }

 private void PopulateFields(Contract contract)
 {
     //Populate all the onscreen controls with the relevant information of the contract
     lblLocation.Text = contract.StartSystem.SolarSystemDisplayName;
     lblDestination.Text = contract.EndSystem.SolarSystemDisplayName;
     lblStatus.Text = contract.Status;
     lblVolume.Text = contract.Volume.ToString("N") + " m3";
     lblExpires.Text = contract.Expiration.ToString();
     lblReward.Text = contract.Reward.ToString("N") + " ISK";
     lblCollateral.Text = contract.Collateral.ToString("N") + " ISK";
 }

        public ActionResult Create(Contract contract)
        {
            if (ModelState.IsValid)
            {
                db.Contracts.Add(contract);
                db.SaveChanges();
                return RedirectToAction("Index");
            }

            return View(contract);
        }

        public QuoteSubscription(IConnection connection, IIdsDispenser dispenser, IQuoteObserver observer, Contract contract)
        {
            CodeContract.Requires(connection != null);
            CodeContract.Requires(observer != null);
            CodeContract.Requires(dispenser != null);

            this.connection = connection;
            this.observer = observer;

            this.Subscribe(contract, dispenser);
        }