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