public virtual ActionResult RelationshipsEdit(UserEditRelationshipsViewModel model)
{
if (ModelState.IsValid)
{
FamilyRepository repos = new FamilyRepository();
// save the new relationship
//Relationship relationship = new Relationship();
//relationship.SourceUser = Target;
//relationship.RelatedUser = db.Users.Find(model.NewRelatedUserId);
//relationship.RelatedUserIsSourceUsers = model.NewRelationshipType;
//repos.UpdateRelationship(db, relationship);
foreach (var item in model.FamilyRelationshipsNew)
{
Relationship relationship = new Relationship();
relationship.SourceUser = Target;
relationship.RelatedUser = db.Users.Find(item.RelatedUserId);
if (item.Relationship == UserEditRelationshipsViewModel.RelationshipTypeViewModel.NotImmediateFamilyMember)
{
repos.RemoveRelationship(db, relationship);
}
else
{
relationship.RelatedUserIsSourceUsers = ((RelationshipType)item.Relationship).Reciprocal();
repos.UpdateRelationship(db, relationship);
}
}
return(RedirectToAction(MVC.User.Details().WithId(Target)));
}
return(View(model));
}
public static int CreateFamily()
{
var user = UserSession.Current.User;
if (user != null)
{
var repo = new FamilyRepository();
Family family = new Family()
{
OwnerCode = user.Code
};
var code = repo.InsertData(family);
if (code > Constants.DEFAULT_CODE)
{
user.FamilyCode = code;
user.StatusCode = (int)Constants.StatusUser.Admin;
var userRepo = new UserRepository((int)Constants.UserAction.Code);
userRepo.UpdateUserData(user.Code, user, new List <int>()
{
(int)Constants.UserField.FamilyCode, (int)Constants.UserField.StatusCode
});
return(code);
}
}
throw new NotImplementedException();
}
public FamilyMemberListViewModel(FamilyRepository family)
{
_family = family;
family.CurrentChild.FamilyMembers.ForEach(_ => FamilyMembers.Add(_));
NewFamilyMemberCommand = new Command(AddFamilyMember);
}
public ProfessionalCareProvidersViewModel(FamilyRepository family)
{
_family = family;
family.CurrentChild.ProfessionalCareProviders.ForEach(_ => CareProviders.Add(_));
AddProviderCommand = new Command(AddProvider);
}
public bool CheckTransportForAgency(Guid AgencyId)
{
connectionFactory = ConnectionHelper.GetConnection();
var context = new DbContext(connectionFactory);
var familyRepository = new FamilyRepository(context);
return(familyRepository.CheckTransportForAgency(AgencyId));
}
public bool CheckParentNameExist(string FirstName, string LastName)
{
connectionFactory = ConnectionHelper.GetConnection();
var context = new DbContext(connectionFactory);
var familyRepository = new FamilyRepository(context);
return(familyRepository.CheckParentNameExist(FirstName, LastName));
}
public DistinguishingFeaturesViewModel(FamilyRepository family)
{
_family = family;
family.CurrentChild.DistinguishingFeatures.ForEach(_ => Features.Add(_));
AddFeatureCommand = new Command(AddFeature);
}
public FamilyTabPage()
{
InitializeComponent();
familyTabPageViewModel = new FamilyTabPageViewModel();
familyRepository = new FamilyRepository();
userRepository = new UserRepository();
toDisplay = new List <User>();
Appearing += OnAppearing;
}
public bool CheckAddress(string address, string apartmentNo, string zipCode)
{
connectionFactory = ConnectionHelper.GetConnection();
var context = new DbContext(connectionFactory);
var familyRepository = new FamilyRepository(context);
return(familyRepository.CheckAddress(address, apartmentNo, zipCode));
}
public HomeTabPage()
{
InitializeComponent();
familyTabPageViewModel = new FamilyTabPageViewModel();
familyRepository = new FamilyRepository();
userRepository = new UserRepository();
Appearing += OnAppearing;
BindingContextChanged += OnBindingContextChanged;
}
public MainPage(User u)
{
user = u;
userRepository = new UserRepository();
familyRepository = new FamilyRepository();
firebaseStorageService = new FirebaseStorageService();
InitializeComponent();
CurrentPageChanged += CurrentPageHasChanged;
Appearing += OnAppearing;
}
public PhotosViewModel(FamilyRepository family, IPhotoPicker photoPicker)
{
_family = family;
_photoPicker = photoPicker;
AddPhotoCommand = new Command(async() => await AddPhoto());
DeletePhotoCommand = new Command <Photo>(DeletePhoto);
family.CurrentChild.Photos.ForEach(_ => Photos.Add(new Photo(_)));
}
public FriendListViewModel(FamilyRepository family, IContactPicker contactPicker)
{
_family = family;
_contactPicker = contactPicker;
family.CurrentChild.Friends.ForEach(_ => Friends.Add(_));
NewFriendCommand = new Command(async() => await AddFriend());
ChangeContactCommand = new Command <Friend>(async(_) => await ChangeContact(_));
DeleteContactCommand = new Command <Friend>(DeleteContact);
}
public void GetFamilyById_ReturnsFamilyWithId()
{
using (var context = new TestHedwigContextProvider().Context)
{
var family = FamilyHelper.CreateFamily(context);
var familyRepo = new FamilyRepository(context);
var res = familyRepo.GetFamilyById(family.Id);
Assert.Equal(family.Id, res.Id);
}
}
// GET api/<controller>/5
public Family Get(int id)
{
Family rtnFamily;
using (SqlUnitOfWork unitOfWork = new SqlUnitOfWork("gp"))
{
FamilyRepository familyRepo = new FamilyRepository(unitOfWork);
rtnFamily = familyRepo.Get(id);
unitOfWork.Commit();
}
return(rtnFamily);
}
public async void GetAllFamilies_FetchListOfAllFamilies_LengthOfTwoExpected()
{
// Arrange
var profile = new MammalAPI.Configuration.Mapper();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(profile));
IMapper mapper = new Mapper(configuration);
//Mock context
var testFamilies = GetTestFamilies();
var contextMock = new Mock <DBContext>();
contextMock.Setup(f => f.Families).ReturnsDbSet(testFamilies);
//Mock Repo
var logger = Mock.Of <ILogger <FamilyRepository> >();
var familyRepoMock = new FamilyRepository(contextMock.Object, logger);
//Mock IActionDescriptorCollectionProvider
var actions = new List <ActionDescriptor>
{
new ActionDescriptor
{
AttributeRouteInfo = new AttributeRouteInfo()
{
Template = "/test",
},
RouteValues = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase)
{
{ "action", "Test" },
{ "controller", "Test" },
},
}
};
var mockDescriptorProvider = new Mock <IActionDescriptorCollectionProvider>();
mockDescriptorProvider.Setup(m => m.ActionDescriptors).Returns(new ActionDescriptorCollection(actions, 0));
//Setup new controller based on mocks
var controller = new FamilyController(familyRepoMock, mapper, mockDescriptorProvider.Object);
//Act
var result = await controller.GetAllFamilies(false);
var contentResult = result as OkObjectResult;
FamilyDTO[] dto = (FamilyDTO[])contentResult.Value;
//Assert
Assert.Equal(2, dto.Length);
}
// GET api/<controller>
public IEnumerable <Family> Get()
{
List <Family> allFamilies;
using (SqlUnitOfWork unitOfWork = new SqlUnitOfWork("gp"))
{
FamilyRepository familyRepo = new FamilyRepository(unitOfWork);
allFamilies = familyRepo.GetAll();
unitOfWork.Commit();
}
return(allFamilies);
}
public UnitOfWork(JobDBContext _context)
{
context = _context;
Awards = new AwardRepository(context);
FamilyMembers = new FamilyMemberRepository(context);
FamilyMemberRoles = new FamilyMemberRoleRepository(context);
Families = new FamilyRepository(context);
Goals = new GoalRepository(context);
JobCategories = new JobCategoryRepository(context);
Jobs = new JobRepository(context);
JobTemplates = new JobTemplateRepository(context);
MemberJobs = new MemberJobRepository(context);
MemberGoals = new MemberGoalRepository(context);
}
public void GetAllFamilies_ExpectedNotNullOrEmpty()
{
// Arrange
var contextMock = new Mock <DBContext>();
contextMock.Setup(f => f.Families).ReturnsDbSet(GetTestFamilies());
var logger = Mock.Of <ILogger <FamilyRepository> >();
var familyRepository = new FamilyRepository(contextMock.Object, logger);
// Act
var expected = familyRepository.GetAllFamilies(false);
// Assert
Assert.NotNull(expected.Result);
Assert.NotEmpty(expected.Result);
}
public virtual ActionResult AddFamilyMember(AddFamilyMemberViewModel model)
{
if (ModelState.IsValid)
{
FamilyRepository repos = new FamilyRepository();
User newUser = repos.AddFamilyMember(db, Target, model.Name, model.Email, model.IsKid);
if (model.IsKid)
{
// add assumed relationship to admin
Relationship relationshipToAdmin = new Relationship();
relationshipToAdmin.SourceUser = Target.Admin;
relationshipToAdmin.RelatedUser = newUser;
relationshipToAdmin.RelatedUserIsSourceUsers = RelationshipType.Child;
repos.UpdateRelationship(db, relationshipToAdmin);
// add assumed relationships to other kids
foreach (User member in Target.Members)
{
if (member.Id == newUser.Id)
{
continue;
}
if (member.Id == Target.Admin.Id)
{
continue;
}
if (!member.IsKid)
{
continue;
}
Relationship relationshipToOtherKid = new Relationship();
relationshipToOtherKid.SourceUser = newUser;
relationshipToOtherKid.RelatedUser = member;
relationshipToOtherKid.RelatedUserIsSourceUsers = RelationshipType.Sibling;
repos.UpdateRelationship(db, relationshipToOtherKid);
}
}
return(RedirectToAction(MVC.User.RelationshipsEdit().WithId(newUser)));
}
return(View(model));
}
public void GetFamilyByName_OneTestFamily_ExpectedNotNull()
{
// Arrange
var contextMock = new Mock <DBContext>();
contextMock.Setup(f => f.Families).ReturnsDbSet(GetTestFamilies());
var logger = Mock.Of <ILogger <FamilyRepository> >();
var familyRepository = new FamilyRepository(contextMock.Object, logger);
var name = "Test Family One";
var actual = GetTestFamilies()[0];
// Act
var expected = familyRepository.GetFamilyByName(name);
// Assert
Assert.NotNull(expected.Result);
Assert.Equal(expected.Result.Name, actual.Name);
}
public int Insert(FamilyViewModel familyViewModel, List <ChildViewModel> childViewModel)
{
AutoMapper.Mapper.Initialize(cfg => cfg.CreateMap <FamilyViewModel, Family>());
var family = AutoMapper.Mapper.Map <FamilyViewModel, Family>(familyViewModel);
AutoMapper.Mapper.Initialize(cfg => cfg.CreateMap <List <ChildViewModel>, List <Child> >());
var children = AutoMapper.Mapper.Map <List <ChildViewModel>, List <Child> >(childViewModel);
connectionFactory = ConnectionHelper.GetConnection();
var context = new DbContext(connectionFactory);
var familyRepository = new FamilyRepository(context);
var childRepository = new ChildRepository(context);
int ParentId = familyRepository.Insert(family);
childRepository.Insert(children, ParentId);
return(ParentId);
}
// POST api/<controller>
public void Post([FromBody] List <Family> families)
{
using (SqlUnitOfWork unitOfWork = new SqlUnitOfWork("gp"))
{
FamilyRepository familyRepo = new FamilyRepository(unitOfWork);
foreach (Family family in families)
{
if (family.FamilyId == null)
{
familyRepo.Insert(family);
}
else
{
familyRepo.Update(family);
}
}
unitOfWork.Commit();
}
}
public ChildProfileViewModel(FamilyRepository family)
{
_family = family;
EditChildDetailsCommand = new Command(async() =>
await PushAsync <BasicDetailsPage, BasicDetailsViewModel>()
);
EditFeaturesCommand = new Command(async() =>
await PushAsync <DistinguishingFeaturesPage, DistinguishingFeaturesViewModel>()
);
EditCareProvidersCommand = new Command(async() =>
await PushAsync <ProfessionalCareProvidersPage, ProfessionalCareProvidersViewModel>()
);
EditDocumentsCommand = new Command(async() =>
await PushAsync <DocumentsPage, DocumentsViewModel>()
);
EditFamilyCommand = new Command(async() =>
await PushAsync <FamilyMemberListPage, FamilyMemberListViewModel>()
);
EditFriendsCommand = new Command(async() =>
await PushAsync <FriendListPage, FriendListViewModel>()
);
EditMedicalNotesCommand = new Command(async() =>
await PushAsync <MedicalNotesPage, MedicalNotesViewModel>()
);
EditPhysicalDetailsCommand = new Command(async() =>
await PushAsync <PhysicalDetailsPage, PhysicalDetailsViewModel>()
);
EditPhotosCommand = new Command(async() =>
await PushAsync <PhotosPage, PhotosViewModel>()
);
EditChecklistCommand = new Command(async() =>
await PushAsync <PreparationChecklistPage, PreparationChecklistViewModel>()
);
ExportChildProdfileCommand = new Command(async() =>
await PushAsync <DocumentRenderPage, DocumentRenderViewModel>()
);
}
public FamilyController(EnterpriseContext context)
{
_familyRepository = new FamilyRepository(context);
}
private void FamilyList()
{
Families = FamilyRepository.List();
}
private void FamilyRead(int familyID)
{
Family = FamilyRepository.Read(familyID);
}
