public static bool ImportSpssAll(StudyUnitVM studyUnit, MainWindowVM mainWindow) { string path = IOUtils.QueryOpenPathName(SPSS_FILTER); if (string.IsNullOrEmpty(path)) { return(false); } try { SpssReader reader = new SpssReader(); if (!reader.ImportVariables(path, studyUnit)) { return(false); } StudyUnit studyUnitModel = studyUnit.StudyUnitModel; mainWindow.RecreateViewModels(); RawData rawData = reader.LoadRawData(path); if (rawData == null) { return(false); } StudyUnitVM newStudyUnit = mainWindow.GetStudyUnit(studyUnitModel); List <StatisticsInfo> statisticsInfos = StatisticsUtils.CreateStatisticsInfos(rawData, newStudyUnit); studyUnitModel.StatisticsInfos = statisticsInfos; mainWindow.RecreateViewModels(); return(true); } catch (Exception ex) { EDOUtils.ShowUnexpectedError(ex); } return(false); }
private static StudyUnit DoLoadStudyUnit(string pathName) { StudyUnit studyUnit = Load <StudyUnit>(pathName); if (studyUnit == null) { return(null); } foreach (Member member in studyUnit.Members) { member.ConvertRoleCodeToRoleName(); } // old data files available(in which Data Collection is not yet tabbed) if (studyUnit.Sampling != null && studyUnit.Samplings.Count == 0) { Sampling sampling = studyUnit.Sampling; sampling.Universes.AddRange(studyUnit.Universes); studyUnit.Samplings.Add(studyUnit.Sampling); } foreach (Sampling sampling in studyUnit.Samplings) { sampling.ConvertMethodCodeToMethodName(); } studyUnit.Sampling = null; studyUnit.Universes.Clear(); studyUnit.CreateBinaryCodeScheme(); return(studyUnit); }
private ResponseVM CreateResponse(Response responseModel) { ResponseVM response = StudyUnit.CreateResponse(responseModel); response.IsQuestionDesignMode = false; return(response); }
public void CreateDataSets(ObservableCollection <VariableVM> variables) { foreach (DataSetVM dataSet in dataSets) { foreach (VariableVM variable in variables) { DataSetVariableVM v = null; bool shouldCreateVariable = (dataSet.Id == StudyUnit.DefaultDataSetId) && !variable.IsCreatedDataSet && !dataSet.IsExistVariable(variable.Id); if (shouldCreateVariable) { v = new DataSetVariableVM(); v.Id = variable.Id; variable.IsCreatedDataSet = true; dataSet.Variables.Add(v); } else { v = dataSet.FindVariable(variable.Id); } if (v != null) { ConceptVM concept = StudyUnit.FindConcept(variable.ConceptId); v.Title = variable.Title; v.Label = variable.Label; v.ConceptTitle = concept == null ? null : concept.Title; } } } }
public static void FillCollectorFields(StudyUnit newStudyUnit) { foreach (Sampling samplingModel in newStudyUnit.Samplings) { Member member = newStudyUnit.FindMember(samplingModel.MemberId); if (member != null) { samplingModel.LastName = member.LastName; samplingModel.FirstName = member.FirstName; samplingModel.Position = member.Position; Organization membersOrganization = newStudyUnit.FindOrganization(member.OrganizationId); if (membersOrganization != null) { samplingModel.OrganizationName = membersOrganization.OrganizationName; } samplingModel.CollectorTypeCode = Options.COLLECTOR_TYPE_INDIVIDUAL; } else { Organization organization = newStudyUnit.FindOrganization(samplingModel.MemberId); if (organization != null) { samplingModel.OrganizationName = organization.OrganizationName; } samplingModel.CollectorTypeCode = Options.COLLECTOR_TYPE_ORGANIZATION; } } }
public ResponseVM SelectAndCreateResponse(ResponseVM sourceResponse) { ResponseVM newResponse = null; if (sourceResponse.IsTypeChoices) { StudyUnit.CompleteResponse(sourceResponse); CodeSchemeVM sourceCodeScheme = sourceResponse.CodeScheme; ObservableCollection <CodeSchemeVM> codeSchemes = new ObservableCollection <CodeSchemeVM>(StudyUnit.CodeSchemes); SelectObjectWindowVM <CodeSchemeVM> vm = new SelectObjectWindowVM <CodeSchemeVM>(codeSchemes); CodeSchemeVM codeScheme = SelectObjectWindow.Select(Resources.SelectResponse, vm) as CodeSchemeVM; //Select Response Style if (codeScheme != null && sourceCodeScheme != codeScheme) { Response responseModel = new Response(); responseModel.TypeCode = Options.RESPONSE_TYPE_CHOICES_CODE; responseModel.Title = codeScheme.Title; newResponse = new ResponseVM(responseModel, codeScheme); } } else { ObservableCollection <ResponseVM> responses = GetCandidateResponses(); SelectObjectWindowVM <ResponseVM> vm = new SelectObjectWindowVM <ResponseVM>(responses); ResponseVM selectedResponse = SelectObjectWindow.Select(Resources.SelectResponse, vm) as ResponseVM; if (selectedResponse != null && sourceResponse != selectedResponse) { newResponse = selectedResponse.Dup(); } } return(newResponse); }
private void CreateVariableInfos() { variableInfos.Clear(); ObservableCollection <VariableVM> variables = StudyUnit.Variables; foreach (VariableVM variable in variables) { VariableInfoVM variableInfo = new VariableInfoVM(variable.Variable); variableInfos.Add(variableInfo); ConceptVM concept = StudyUnit.FindConcept(variable.ConceptId); if (concept != null) { variableInfo.ConceptTitle = concept.Title; } QuestionVM question = StudyUnit.FindQuestion(variable.QuestionId); if (question != null) { variableInfo.QuestionTitle = question.Content; } UniverseVM universe = StudyUnit.FindUniverse(variable.UniverseId); if (universe != null) { variableInfo.UniverseTitle = universe.Title; } variableInfo.VariableType = Options.FindResponseTypeLabel(variable.ResponseTypeCode); } selectedVariableInfoItem = null; }
public void Init() { List <string> ids = controlConstructScheme.Sequence.ControlConstructIds; foreach (string id in ids) { QuestionConstruct questionConstructModel = controlConstructScheme.FindQuestionConstruct(id); if (questionConstructModel != null) { QuestionVM question = StudyUnit.FindQuestion(questionConstructModel.QuestionId); Debug.Assert(question != null, "Question not found id=" + questionConstructModel.QuestionId); QuestionConstructVM questionConstruct = new QuestionConstructVM(questionConstructModel, question); InitConstruct(questionConstruct); constructModels.Add(questionConstructModel); constructs.Add(questionConstruct); continue; } QuestionGroupConstruct questionGroupConstructModel = controlConstructScheme.FindQuestionGroupConstruct(id); if (questionGroupConstructModel != null) { QuestionGroupVM questionGroup = StudyUnit.FindQuestionGroup(questionGroupConstructModel.QuestionGroupId); QuestionGroupConstructVM questionGroupConstruct = new QuestionGroupConstructVM(questionGroupConstructModel, questionGroup); InitConstruct(questionGroupConstruct); constructModels.Add(questionGroupConstructModel); constructs.Add(questionGroupConstruct); continue; } Statement statementModel = controlConstructScheme.FindStatement(id); if (statementModel != null) { StatementVM statement = new StatementVM(statementModel); InitConstruct(statement); constructModels.Add(statementModel); constructs.Add(statement); continue; } IfThenElse ifThenElseModel = controlConstructScheme.FindIfThenElse(id); if (ifThenElseModel != null) { IfThenElseVM ifThenElse = new IfThenElseVM(ifThenElseModel); InitConstruct(ifThenElse); constructModels.Add(ifThenElseModel); constructs.Add(ifThenElse); } } List <QuestionConstructVM> questionConstructs = QuestionConstructs; foreach (ConstructVM construct in constructs) { if (construct is IfThenElseVM) { IfThenElseVM ifThenElse = (IfThenElseVM)construct; ifThenElse.ThenConstructs = ThenConstructs; } } modelSyncher = new ModelSyncher <ConstructVM, IConstruct>(this, constructs, constructModels); InitTitle(); }
public static List <string> CollectIds(StudyUnit studyUnit) { List <string> ids = new List <string>(); //0. StudyUnit itself CollectIds(studyUnit, ids); //1. Event CollectIds(studyUnit.Events, ids); //2. Member CollectIds(studyUnit.Members, ids); //3. Organization CollectIds(studyUnit.Organizations, ids); //4. Abstract CollectIds(studyUnit.Abstract, ids); //5. Coverage CollectIds(studyUnit.Coverage, ids); //6. Funding Agency CollectIds(studyUnit.FundingInfos, ids); //6-1. Organization including CollectIds(FundingInfo.GetOrganizations(studyUnit.FundingInfos), ids); //7.Universe CollectIds(Sampling.GetUniverses(studyUnit.Samplings), ids); //8.Sampling CollectIds(studyUnit.Samplings, ids); //9. Concept Scheme CollectIds(studyUnit.ConceptSchemes, ids); //9-1. Concept CollectIds(ConceptScheme.GetConcepts(studyUnit.ConceptSchemes), ids); //10. Question CollectIds(studyUnit.Questions, ids); //10-1. Answer CollectIds(Question.GetResponses(studyUnit.Questions), ids); //11. Category Scheme CollectIds(studyUnit.CategorySchemes, ids); //11-1. Category CollectIds(CategoryScheme.GetCategories(studyUnit.CategorySchemes), ids); //12. Code Scheme CollectIds(studyUnit.CodeSchemes, ids); //12-1. Code CollectIds(CodeScheme.GetCodes(studyUnit.CodeSchemes), ids); //13. Variable Scheme CollectIds(studyUnit.VariableScheme, ids); //14. Variable CollectIds(studyUnit.Variables, ids); //14-1. Answer CollectIds(Variable.GetResponses(studyUnit.Variables), ids); //15. Dataset CollectIds(studyUnit.DataSets, ids); //16. Data File CollectIds(studyUnit.DataFiles, ids); //17. Order of Question CollectIds(studyUnit.ControlConstructSchemes, ids); //17-1.Sequence CollectIds(ControlConstructScheme.GetSequences(studyUnit.ControlConstructSchemes), ids); //17-2.Constructs CollectIds(ControlConstructScheme.GetConstructs(studyUnit.ControlConstructSchemes), ids); return(ids); }
public static void MergeDataSet(this StudyUnit curStudyUnit, StudyUnit newStudyUnit) { if (newStudyUnit.DataSets.Count > 0 && newStudyUnit.DataSets[0].Title == EDOConstants.LABEL_ALL) { newStudyUnit.DataSets.RemoveAt(0); } curStudyUnit.DataSets.AddRange(newStudyUnit.DataSets); }
public static void SetDataCollectionDate(this StudyUnit study, string dtJson) { var collectionEvent = EnsureCollectionEventExists(study); var dateSpec = FormMappingHelper.GetDateFromJson(dtJson); collectionEvent.DataCollectionDate = dateSpec; }
public static void SetModeOfDataCollection(this StudyUnit study, string content) { var collectionEvent = EnsureCollectionEventExists(study); var modeOfCollection = new DataCollectionItem(); modeOfCollection.Description.Current = content; collectionEvent.ModesOfCollection.Add(modeOfCollection); }
public void RemoveConceptExternal(ConceptVM concept) { StudyUnit.OnRemoveConcept(concept); concepts.Remove(concept); if (SelectedConceptItem == concept) { SelectedConceptItem = null; } }
public void RemoveConceptScheme() { List <ConceptVM> concepts = new List <ConceptVM>(); concepts.AddRange(SelectedConceptScheme.Concepts); StudyUnit.OnRemoveConcepts(concepts); conceptSchemes.Remove(SelectedConceptScheme); SelectedConceptScheme = conceptSchemes.LastOrNull(); }
private static EDOModel LoadStudyUnit(string pathName) { StudyUnit studyUnit = DoLoadStudyUnit(pathName); EDOModel newEdoModel = new EDOModel(); newEdoModel.StudyUnits.Add(studyUnit); return(newEdoModel); }
public void SelectBook() { BookVM book = StudyUnit.SelectBook(FromRelation()); if (book != null) { SelectedBookItem = book; } }
private DataSetVariableVM createDataSetVariable(string variableId) { VariableVM variable = StudyUnit.FindVariable(variableId); if (variable == null) { return(null); } return(createDataSetVariable(variable)); }
public static void MergeMember(this StudyUnit curStudyUnit, StudyUnit newStudyUnit) { curStudyUnit.Members.AddRange(newStudyUnit.Members); foreach (Organization organization in newStudyUnit.Organizations) { List <string> existNames = Organization.GetOrganizationNames(curStudyUnit.Organizations); organization.OrganizationName = EDOUtils.UniqueLabel(existNames, organization.OrganizationName); curStudyUnit.Organizations.Add(organization); } }
public SelectStudyUnitWindowVM(EDOModel fromModel, EDOModel toModel, StudyUnit curStudyUnit, DDIImportOption importOption) { this.fromModel = fromModel; this.toModel = toModel; fromStudyUnits = new ObservableCollection <StudyUnit>(fromModel.StudyUnits); this.FromStudyUnit = fromModel.StudyUnits.FirstOrDefault(); toStudyUnits = new ObservableCollection <StudyUnit>(toModel.StudyUnits); this.ToStudyUnit = curStudyUnit; this.importOption = importOption; }
[Test] //4 units, all have no prerequisites public void CheckPrerequisitesCorrect_NoPrerequisites_NoException() { string[] codesForUnits = { "UECS1111", "UECS2222", "UECS3333" }; List <string>[] preqsForUnits = new List <string> [codesForUnits.Length]; for (int i = 0; i < preqsForUnits.Length; i++) { preqsForUnits[i] = new List <String>(); } StudyUnit.CheckPrerequisitesCorrect(CreateStudyListForTesting(codesForUnits, preqsForUnits)); }
public void SelectResponse() { ResponseVM newResponse = StudyUnit.SelectAndCreateResponse(SelectedVariable.Response); if (newResponse != null) { newResponse.IsQuestionDesignMode = false; SelectedVariable.Response = newResponse; Window.UpdateTemplate(); } }
public ResponseVM CreateResponse(Response responseModel) { CodeSchemeVM codeScheme = null; if (responseModel.IsTypeChoices) { codeScheme = StudyUnit.FindCodeScheme(responseModel); } ResponseVM response = new ResponseVM(responseModel, codeScheme); return(response); }
public bool CanRemoveConceptExternal(ConceptVM concept) { if (concept == null) { return(false); } if (concept.InEdit) { return(false); } return(StudyUnit.CanRemoveConcept(concept)); }
public static void CheckDuplicate(StudyUnit orgStudyUnit, StudyUnit newStudyUnit) { List <string> orgIds = CollectIds(orgStudyUnit); List <string> newIds = CollectIds(newStudyUnit); foreach (string newId in newIds) { if (orgIds.Contains(newId)) { Debug.WriteLine(string.Format("duplicate id {0}", newId)); } } }
public void RemoveQuestion() { using (UndoTransaction tx = new UndoTransaction(UndoManager)) { StudyUnit.OnRemoveQuestion(SelectedQuestion); SelectedQuestions.Remove(SelectedQuestion); SelectedQuestionItem = null; ConceptVM concept = SelectedConcept; UpdateModel(false); SelectedConcept = concept; tx.Commit(); } }
public void Init() { allObjects.Clear(); objects.Clear(); allObjects.AddRange(StudyUnit.RelatedMetaData(bookRelationType)); Filter(""); SearchText = ""; SelectedObject = Find(objects, metaDataId); metaDataId = null; }
private void CreateVariableFor(QuestionVM question, int questionIndex) { VariableGenerationInfo oldInfo = question.VariableGenerationInfo; VariableGenerationInfo newInfo = question.CreateVariableGenerationInfo(); if (oldInfo != null && oldInfo.VariableGenerationType == newInfo.VariableGenerationType) { return; } question.VariableGenerationInfo = newInfo; // remove old variables List <VariableVM> generatedVariables = VariableVM.FindByQuestionId(Variables, question.Id); Debug.WriteLine(generatedVariables.Count); int removeIndex = Variables.Count; foreach (VariableVM variable in generatedVariables) { if (removeIndex == Variables.Count) { removeIndex = Variables.IndexOf(variable); } StudyUnit.OnRemoveVariable(variable); Variables.Remove(variable); } // create single or multiple variables if (newInfo.VariableGenerationType == VariableGenerationType.SingleVariable) { CreateVariable((variableMovel) => { variableMovel.Title = "V" + (questionIndex + 1); }, question, removeIndex); } else { CodeSchemeVM codeScheme = question.Response.CodeScheme; ICollection <CodeVM> codes = codeScheme.Codes; string variablePrefix = "V" + (questionIndex + 1) + "_"; foreach (CodeVM code in codes) { CreateVariable((variableModel) => { variableModel.Title = variablePrefix + code.Value; variableModel.Label = code.Label; variableModel.Response = question.DupResponseModel(); variableModel.Response.TypeCode = Options.RESPONSE_TYPE_CHOICES_CODE; variableModel.Response.CodeSchemeId = StudyUnit.BinaryCodeSchemeId; }, question, removeIndex++); } } }
public static void MergeDataFile(this StudyUnit curStudyUnit, StudyUnit newStudyUnit) { int upper = newStudyUnit.DataFiles.Count - 1; for (int i = upper; i >= 0; i--) { DataFile dataFile = newStudyUnit.DataFiles[i]; if (newStudyUnit.FindDataSet(dataFile.DataSetId) == null) { newStudyUnit.DataFiles.RemoveAt(i); } } curStudyUnit.DataFiles.AddRange(newStudyUnit.DataFiles); }
public void RemoveCodeScheme() { if (SelectedCodeScheme == null) { return; } using (UndoTransaction tx = new UndoTransaction(UndoManager)) { StudyUnit.RemoveCodeSchemeFromResponse(SelectedCodeScheme); SelectedCodeScheme.Codes.Clear(); codeSchemes.Remove(SelectedCodeScheme); tx.Commit(); } SelectedCodeScheme = null; }
public BookVM AddBookExternal(BookRelation relation) { BookVM newBook = AddOrEditBook(null, relation); if (newBook != null) { using (UndoTransaction tx = new UndoTransaction(UndoManager)) { books.Add(newBook); StudyUnit.OnRemoveBooks(); tx.Commit(); } } return(newBook); }
/// <summary> /// Assigns a QualityStatement to a StudyUnit. /// </summary> public void AssignQualityStatementToStudy() { // Create a new StudyUnit with some basic information. StudyUnit study = new StudyUnit(); study.DublinCoreMetadata.Title.Current = "Sample Study"; // Grab the QualityStatement. var statement = CreateAndRegisterQualityStatement(); // Assign the QualityStatement to the StudyUnit. study.QualityStatements.Add(statement); // Register the StudyUnit with the Repository. var client = RepositoryIntro.GetClient(); client.RegisterItem(study, new CommitOptions()); }
public override void Execute() { // Ask the user to select a file. var dlg = new OpenFileDialog(); bool? result = dlg.ShowDialog(); // If the user pressed Cancel, don't continue. if (!result.HasValue || !result.Value) { this.Result.IsSuccessful = false; this.Result.MessageTitle = "User Cancelled"; this.Result.MessageText = "The user cancelled the operation."; this.Result.MessageDetails = "Even more details can go here."; return; } // Now we'll create a new StudyUnit with the same name of that // file. Of course, if the file contained some interesting // information, we could process the file and set that information // as part of our new object. var myStudy = new StudyUnit(); myStudy.DublinCoreMetadata.Title.Current = Path.GetFileNameWithoutExtension(dlg.FileName); // Add any new items to a collection, and use the Api object // to tell Designer about them. var newItems = new Collection<IVersionable>(); newItems.Add(myStudy); this.Api.Import(newItems, true); // Add the new item to the ModifiedItems of the Result property, // to let Colectica know that you created something new. this.Result.ModifiedItems.Add(myStudy); }
public SampleVersionableViewModel(StudyUnit study) { this.Study = study; }