Beispiel #1
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,ReferenceArticlesId,ProjectStepsId,StepsResearchId,WorkItemsId")] ProjectResearchPlan projectResearchPlan)
        {
            if (id != projectResearchPlan.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(projectResearchPlan);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ProjectResearchPlanExists(projectResearchPlan.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["ProjectStepsId"]      = new SelectList(_context.Set <ProjectSteps>(), "Id", "Id", projectResearchPlan.ProjectStepsId);
            ViewData["ReferenceArticlesId"] = new SelectList(_context.Set <ReferenceArticles>(), "Id", "Id", projectResearchPlan.ReferenceArticlesId);
            ViewData["StepsResearchId"]     = new SelectList(_context.Set <StepsResearch>(), "Id", "Id", projectResearchPlan.StepsResearchId);
            ViewData["WorkItemsId"]         = new SelectList(_context.Set <WorkItems>(), "Id", "Id", projectResearchPlan.WorkItemsId);
            return(View(projectResearchPlan));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Temperature,Duration,Cycles")] Pcr1 pcr1)
        {
            if (id != pcr1.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(pcr1);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!Pcr1Exists(pcr1.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(pcr1));
        }
Beispiel #3
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,AlimTarihi,AlinanKisi,TeslimAlan,Marka,TeslimAlinanAdet,WorkItemsId")] WorkItemType workItemType)
        {
            if (id != workItemType.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workItemType);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkItemTypeExists(workItemType.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["WorkItemsId"] = new SelectList(_context.WorkItems, "Id", "Id", workItemType.WorkItemsId);
            return(View(workItemType));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,SampleExtractionId,NanogramDegeri,TeslimAlan,TespitDegeri1,TespitDegeri2,TespitDegeri3,TespitDegeri4,TespitDegeri5,TespitDegeri6,TespitDegeri7,TespitDegeri8,TespitDegeri9,GorselLinki,Onay")] Results results)
        {
            if (id != results.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(results);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ResultsExists(results.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["SampleExtractionId"] = new SelectList(_context.Set <SampleExtraction>(), "Id", "Id", results.SampleExtractionId);
            return(View(results));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,OligoNucleotideId,OligoNucleotideMixBId")] OligonucleotideInfo oligonucleotideInfo)
        {
            if (id != oligonucleotideInfo.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(oligonucleotideInfo);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!OligonucleotideInfoExists(oligonucleotideInfo.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["OligoNucleotideId"]     = new SelectList(_context.OligoNucleotide, "Id", "Id", oligonucleotideInfo.OligoNucleotideId);
            ViewData["OligoNucleotideMixBId"] = new SelectList(_context.Set <OligoNucleotideMixB>(), "Id", "Id", oligonucleotideInfo.OligoNucleotideMixBId);
            return(View(oligonucleotideInfo));
        }
Beispiel #6
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Name,RoleLevel,CanAssignTask")] EmployeeRoles employeeRoles)
        {
            if (id != employeeRoles.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(employeeRoles);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!EmployeeRolesExists(employeeRoles.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(employeeRoles));
        }
Beispiel #7
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Kod,Hacim")] Enzyme enzyme)
        {
            if (id != enzyme.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(enzyme);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!EnzymeExists(enzyme.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(enzyme));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Link")] ResultSlip resultSlip)
        {
            if (id != resultSlip.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(resultSlip);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ResultSlipExists(resultSlip.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(resultSlip));
        }
Beispiel #9
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,MixBCode,Aciklama,HazirlamaTarihi")] OligoNucleotideMixB oligoNucleotideMixB)
        {
            if (id != oligoNucleotideMixB.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(oligoNucleotideMixB);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!OligoNucleotideMixBExists(oligoNucleotideMixB.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(oligoNucleotideMixB));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Metodlar,Referans")] StepsResearch stepsResearch)
        {
            if (id != stepsResearch.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(stepsResearch);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!StepsResearchExists(stepsResearch.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(stepsResearch));
        }
Beispiel #11
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,WorkItemTypeId,WorkItemUsed,WorkItemDelivered,WorkItemRemaining")] WorkItemMonitor workItemMonitor)
        {
            if (id != workItemMonitor.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workItemMonitor);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkItemMonitorExists(workItemMonitor.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["WorkItemTypeId"] = new SelectList(_context.WorkItemType, "Id", "Id", workItemMonitor.WorkItemTypeId);
            return(View(workItemMonitor));
        }
Beispiel #12
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,ItemName,Birimi,Adedi")] WorkItems workItems)
        {
            if (id != workItems.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(workItems);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!WorkItemsExists(workItems.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(workItems));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,ProviderName")] SampleProvider sampleProvider)
        {
            if (id != sampleProvider.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(sampleProvider);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SampleProviderExists(sampleProvider.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(sampleProvider));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,NumuneAlisTarihi,TeslimAlinan,TeslimAlan,NumuneIsim,NumuneKodu,NumuneTuru,NumuneKurum,DiagenNukleikAsidKodu,EkstraksiyonTarihi,YapanKisi,Yontem,KullanilanKit,Aciklama")] SampleExtraction sampleExtraction)
        {
            if (id != sampleExtraction.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(sampleExtraction);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!SampleExtractionExists(sampleExtraction.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(sampleExtraction));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,SiparisKodu,SiparisTarihi,AlinmaTarihi,HedefGenTur,OligoNucleotideType,BesIsaretleme,NucleotideSequence,UcIsaretleme,NucleotideLength,Tm,GcPercent,SelfComp,Self3Comp,HedefBolgeUzunlugu,PrimerDimertur,KaynakTasarlananSistem")] OligoNucleotide oligoNucleotide)
        {
            if (id != oligoNucleotide.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(oligoNucleotide);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!OligoNucleotideExists(oligoNucleotide.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(oligoNucleotide));
        }
Beispiel #16
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Kod,Hacim,Sonuc")] NucleicAcid nucleicAcid)
        {
            if (id != nucleicAcid.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(nucleicAcid);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!NucleicAcidExists(nucleicAcid.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(nucleicAcid));
        }
Beispiel #17
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,ProjectRoles,SorumluKisiId,YardimciKisiler,Status,Tamamlanan,BaslangicTarihi,BitisTarihi,KalanSure,CalismaSure")] ProjectState projectState)
        {
            if (id != projectState.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(projectState);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ProjectStateExists(projectState.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["SorumluKisiId"] = new SelectList(_context.Employees, "Id", "Id", projectState.SorumluKisiId);
            return(View(projectState));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,Tckn,AdSoyad,Unvan,Email,FotografUrl,CepTelefonu,EvTelefonu,IsTelefonu,DogumTarihi,KullaniciAdi,Parola,EmployeeRoleId,IsActive")] Employees employees)
        {
            if (id != employees.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(employees);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!EmployeesExists(employees.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["EmployeeRoleId"] = new SelectList(_context.EmployeeRoles, "Id", "Id", employees.EmployeeRoleId);
            return(View(employees));
        }
Beispiel #19
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,PlananIslem")] ProjectSteps projectSteps)
        {
            if (id != projectSteps.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(projectSteps);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ProjectStepsExists(projectSteps.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(projectSteps));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,ReferansMakaleler")] ReferenceArticles referenceArticles)
        {
            if (id != referenceArticles.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(referenceArticles);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ReferenceArticlesExists(referenceArticles.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(referenceArticles));
        }
Beispiel #21
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Cihaz,OperatorAdi,Tarih,KayitAdi,CalisanGen,ResultSlipId,Results,MixAId,MixBId,EnzymeId,DH20,DenaturationId,Pcr1Id,Pcr2Id,CoolingId,NucleicAcidId,CalismaAmaci,Yorum")] PcrProcess pcrProcess)
        {
            if (id != pcrProcess.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(pcrProcess);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!PcrProcessExists(pcrProcess.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["CoolingId"]      = new SelectList(_context.Cooling, "Id", "Id", pcrProcess.CoolingId);
            ViewData["DenaturationId"] = new SelectList(_context.Denaturation, "Id", "Id", pcrProcess.DenaturationId);
            ViewData["EnzymeId"]       = new SelectList(_context.Enzyme, "Id", "Id", pcrProcess.EnzymeId);
            ViewData["MixAId"]         = new SelectList(_context.MixA, "Id", "Id", pcrProcess.MixAId);
            ViewData["MixBId"]         = new SelectList(_context.MixB, "Id", "Id", pcrProcess.MixBId);
            ViewData["NucleicAcidId"]  = new SelectList(_context.NucleicAcid, "Id", "Id", pcrProcess.NucleicAcidId);
            ViewData["Pcr1Id"]         = new SelectList(_context.Pcr1, "Id", "Id", pcrProcess.Pcr1Id);
            ViewData["Pcr2Id"]         = new SelectList(_context.Pcr2, "Id", "Id", pcrProcess.Pcr2Id);
            ViewData["ResultSlipId"]   = new SelectList(_context.Set <ResultSlip>(), "Id", "Id", pcrProcess.ResultSlipId);
            return(View(pcrProcess));
        }
        public async Task <IActionResult> Edit(int id, [Bind("Id,UhtNumber,SdfNumber,ProjeBaslangicTarihi,ProjeBitisTarihi,KullanilacakMesai,BeklenenNumuneAdedi,ProjeSorumlusu,ProjeTuru,IlgiliMusteri,IlgiliMusteriTelNo,IlgiliMusteriEmail,IlgiliMusteriTemsilcisi,ProjeServerLink,ProjeAciklama,ProjeSonDurum,ProjectResearchPlanId,WorkItemMonitorId,OligonucleotideInfoId,SampleExtractionId,PcrProcessId,ResultsId,ProjectStateId,SampleProviderId,ProjectReport")] Projects projects)
        {
            if (id != projects.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(projects);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!ProjectsExists(projects.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            ViewData["OligonucleotideInfoId"] = new SelectList(_context.OligonucleotideInfo, "Id", "Id", projects.OligonucleotideInfoId);
            ViewData["PcrProcessId"]          = new SelectList(_context.PcrProcess, "Id", "Id", projects.PcrProcessId);
            ViewData["ProjectResearchPlanId"] = new SelectList(_context.ProjectResearchPlan, "Id", "Id", projects.ProjectResearchPlanId);
            ViewData["ProjectStateId"]        = new SelectList(_context.Set <ProjectState>(), "Id", "Id", projects.ProjectStateId);
            ViewData["ResultsId"]             = new SelectList(_context.Set <Results>(), "Id", "Id", projects.ResultsId);
            ViewData["SampleExtractionId"]    = new SelectList(_context.Set <SampleExtraction>(), "Id", "Id", projects.SampleExtractionId);
            ViewData["SampleProviderId"]      = new SelectList(_context.Set <SampleProvider>(), "Id", "Id", projects.SampleProviderId);
            ViewData["WorkItemMonitorId"]     = new SelectList(_context.Set <WorkItemMonitor>(), "Id", "Id", projects.WorkItemMonitorId);
            return(View(projects));
        }