public ActionResult Friends()
{
var user = userService.GetUserByEmail(HttpContext.User.Identity.Name);
var requests = profileService.GetAllRequests(user.Id);
return(View(ProfileMapper.Map(requests)));
}
public IProfileModel Update(IProfileModel model)
{
// Validate model
BusinessWorkflowBase.ValidateRequiredNullableID(model.Id);
//BusinessWorkflowBase.ValidateRequiredString(model.Name, nameof(model.Name));
// Find existing entity
// ReSharper disable once PossibleInvalidOperationException
var existingEntity = ProfilesRepository.Get(model.Id.Value);
// Check if we would be applying identical information, if we are, just return the original
// ReSharper disable once SuspiciousTypeConversion.Global
if (ProfileMapper.AreEqual(model, existingEntity))
{
return(ProfileMapper.MapToModel(existingEntity));
}
// Map model to an existing entity
ProfileMapper.MapToEntity(model, ref existingEntity);
existingEntity.UpdatedDate = BusinessWorkflowBase.GenDateTime;
// Update it
ProfilesRepository.Update(ProfileMapper.MapToEntity(model));
// Try to Save Changes
ProfilesRepository.SaveChanges();
// Return the new value
return(Get(existingEntity.Id));
}
public IProfileModel Create(IProfileModel model)
{
// Validate model
BusinessWorkflowBase.ValidateIDIsNull(model.Id);
//BusinessWorkflowBase.ValidateRequiredString(model.Name, nameof(model.Name));
// Search for an Existing Record (Don't allow Duplicates
var results = Search(ProfileMapper.MapToSearchModel(model));
if (results.Any())
{
return(results.First());
} // Return the first that matches
// Map model to a new entity
var newEntity = ProfileMapper.MapToEntity(model);
newEntity.CreatedDate = BusinessWorkflowBase.GenDateTime;
newEntity.UpdatedDate = null;
newEntity.Active = true;
// Add it
ProfilesRepository.Add(newEntity);
// Try to Save Changes
ProfilesRepository.SaveChanges();
// Return the new value
return(Get(newEntity.Id));
}
public async Task <Profile> UpdateProfile(Profile model)
{
var entity = await _profilesRepository.UpsertProfile(ProfileMapper.ToProfileEntity(model));
var contract = ProfileMapper.ToProfileContract(entity);
return(contract);
}
public void Verify_MapToSearchModel_AssignsProfileSearchProperties()
{
// Arrange
var mapper = new ProfileMapper();
var model = ProfilesMockingSetup.DoMockingSetupForProfileModel();
// Act
var searchModel = mapper.MapToSearchModel(model.Object);
// Assert
}
public ProfileController(
IProfileProvider profileProvider,
ProfileMapper profileMapper,
ICurrentUserFactory userFactory)
: base(userFactory)
{
_profileProvider = profileProvider;
_profileMapper = profileMapper;
}
public void Verify_MapToModelLite_AssignsLiteOnlyProfileProperties()
{
// Arrange
var mapper = new ProfileMapper();
var entity = ProfilesMockingSetup.DoMockingSetupForProfile();
// Act
var model = mapper.MapToModelLite(entity.Object);
// Assert
// <None>
// Related Objects
// <None>
}
public void Verify_AreEqual_WithDifferentObjects_ReturnsFalse()
{
// Arrange
var mapper = new ProfileMapper();
var model = ProfilesMockingSetup.DoMockingSetupForProfileModel(1);
var entity = ProfilesMockingSetup.DoMockingSetupForProfile(2);
// Act
var result = mapper.AreEqual(model.Object, entity.Object);
// Assert
Assert.False(result);
}
public async Task <Profile> GetProfile(string profileId)
{
var profileEntity = await _profilesRepository.GetProfile(profileId);
if (profileEntity == null)
{
return(null);
}
var contract = ProfileMapper.ToProfileContract(profileEntity);
return(contract);
}
public async Task <IResponseWrapper> GetProfileById(int id)
{
try
{
var response = await localDataSource.GetProfileById(id);
return(new Success <Core.Model.Profile>(ProfileMapper.ConvertFromDto(response)));
}
catch (Exception e)
{
Debug.WriteLine("[ProfileRepository.GetProfileById()] Error: " + e.Message);
return(new Error(e.Message));
}
}
public async Task <IResponseWrapper> UpdateProfile(Core.Model.Profile profile)
{
try
{
var response = await localDataSource.UpdateProfile(ProfileMapper.ConvertToDto(profile));
return(new Success <bool>(response));
}
catch (Exception e)
{
Debug.WriteLine("[ProfileRepository.UpdateProfile()] Error: " + e.Message);
return(new Error(e.Message));
}
}
public ActionResult Index(SearchModel model, int page = 1)
{
var bllProfiles = profiles.Find(model.StringKey, model.City);
var result = ProfileMapper.Map(bllProfiles);
model.Profiles = new GenericPaginationModel <ProfileModel>(page, 5, result.ToList());
if (Request.IsAjaxRequest())
{
return(PartialView("_Search", model));
}
else
{
return(View(model));
}
}
public async Task <IResponseWrapper> GetAllProfiles()
{
try
{
var response = await localDataSource.GetAllProfiles();
var list = ProfileMapper.ConvertFromProfilesDTO(response).ToList();
return(new Success <List <Core.Model.Profile> >(list));
}
catch (Exception e)
{
Debug.WriteLine("[SignInRepository.GetAllProfiles()] Error: " + e.Message);
return(new Error(e.Message));
}
}
/// <summary>
/// The method for profile searching
/// </summary>
/// <param name="stringKey"></param>
/// <param name="city"></param>
/// <returns></returns>
public IEnumerable <BllProfile> Find(string stringKey = "", string city = null)
{
var profiles = uow.Profiles.GetAll();
if (!ReferenceEquals(stringKey, null))
{
profiles = profiles.Where(p => (p.FirstName + " " + p.LastName).Contains(stringKey));
}
if (!ReferenceEquals(city, null))
{
profiles = profiles.Where(p => p.City != null && p.City.Contains(city));
}
return(ProfileMapper.Map(profiles));
}
public void Verify_MapToModel_AssignsProfileProperties()
{
// Arrange
var mapper = new ProfileMapper();
var entity = ProfilesMockingSetup.DoMockingSetupForProfile();
// Act
var model = mapper.MapToModel(entity.Object);
// Assert
// <None>
// Related Objects
// <None>
// Associated Objects
Assert.Equal(entity.Object.OriginProfiles?.Count, model.OriginProfiles?.Count);
}
public void Verify_MapToEntity_AssignsProfileProperties()
{
// Arrange
var mapper = new ProfileMapper();
var model = ProfilesMockingSetup.DoMockingSetupForProfileModel();
// Act
var entity = mapper.MapToEntity(model.Object);
// Assert
// <None>
// Related Objects
// <None>
// Associated Objects
//Assert.Equal(model.Object.OriginProfiles?.Count, entity.OriginProfiles?.Count);
model.VerifyGet(x => x.OriginProfiles, Times.Once);
}
public Profile View(string profile)
{
DataSet dataSet = this.repository.View(profile);
DataTable table = dataSet.Tables[0];
Dictionary <String, String> data = new Dictionary <string, string>();
for (int i = 0; i < table.Rows.Count; i++)
{
//table.Rows[i][0] RESOURCE_NAME
//table.Rows[i][1] LIMIT
data.Add(table.Rows[i][0].ToString(), table.Rows[i][1].ToString());
}
Profile result = ProfileMapper.Map(data);
result.Name = profile;
return(result);
}
public ReviewController(
IMentorReviewProvider mentorReviewProvider,
IMentorProvider mentorProvider,
IProfileProvider profileProvider,
IScrumReviewProvider scrumReviewProvider,
ITraineeReviewProvider traineeReviewProvider,
ProfileMapper profileMapper,
ScrumReviewMapper scrumMasterMapper,
MentorReviewMapper mentorReviewMapper,
TraineeReviewMapper traineeReviewMapper)
{
_mentorReviewProvider = mentorReviewProvider;
_mentorProvider = mentorProvider;
_profileProvider = profileProvider;
_scrumReviewProvider = scrumReviewProvider;
_traineeReviewProvider = traineeReviewProvider;
_profileMapper = profileMapper;
_scrumMasterMapper = scrumMasterMapper;
_mentorReviewMapper = mentorReviewMapper;
_traineeReviewMapper = traineeReviewMapper;
}
public void Verify_MapToEntity_WithExistingEntity_AssignsProfileProperties()
{
// Arrange
var mapper = new ProfileMapper();
var model = ProfilesMockingSetup.DoMockingSetupForProfileModel();
// Act
IProfile existingEntity = new Profile { Id = 1 };
mapper.MapToEntity(model.Object, ref existingEntity);
// Assert
// <None>
// Related Objects
// <None>
// Associated Objects
model.VerifyGet(x => x.OriginProfiles, Times.Once);
//Assert.Equal(model.Object.OriginProfiles?.Count, existingEntity.OriginProfiles?.Count);
}
public ReportController(IJiraProvider jiraProvider, IProfileProvider profileProvider, ProfileMapper profileMapper)
{
_jiraProvider = jiraProvider;
_profileProvider = profileProvider;
_profileMapper = profileMapper;
}
public void Verify_MapToModel_AssignsProfileProperties()
{
// Arrange
var mapper = new ProfileMapper();
var entity = ProfilesMockingSetup.DoMockingSetupForProfile();
// Act
var model = mapper.MapToModel(entity.Object);
// Assert
// <None>
// Related Objects
// <None>
// Associated Objects
Assert.Equal(entity.Object.OriginProfiles?.Count, model.OriginProfiles?.Count);
}
public void Verify_MapToModelLite_AssignsLiteOnlyProfileProperties()
{
// Arrange
var mapper = new ProfileMapper();
var entity = ProfilesMockingSetup.DoMockingSetupForProfile();
// Act
var model = mapper.MapToModelLite(entity.Object);
// Assert
// <None>
// Related Objects
// <None>
}
public void Verify_MapToSearchModel_AssignsProfileSearchProperties()
{
// Arrange
var mapper = new ProfileMapper();
var model = ProfilesMockingSetup.DoMockingSetupForProfileModel();
// Act
var searchModel = mapper.MapToSearchModel(model.Object);
// Assert
}
public void Verify_AreEqual_WithEqualObjects_ReturnsTrue()
{
// Arrange
var mapper = new ProfileMapper();
var model = ProfilesMockingSetup.DoMockingSetupForProfileModel(1);
var entity = ProfilesMockingSetup.DoMockingSetupForProfile(1);
// Act
var result = mapper.AreEqual(model.Object, entity.Object);
// Assert
Assert.True(result);
}
/// <summary>
/// Asynchronously generates bindings for the API described by the given <see cref="IGeneratorSettings"/>
/// object.
///
/// Broadly, this takes the following steps:
/// 1) Load the base API.
/// 2) Bake overrides into the API
/// 3) Bake Documentation into the API
/// 4) Create mappings between OpenGL types and C# types
/// 5) Apply the mappings to the API
/// 6) Bake convenience overloads into the API (adding unsafe, etc)
/// 7) Write the bindings to the files.
///
/// </summary>
/// <param name="generatorSettings">The settings describing the API.</param>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
private static async Task GenerateBindingsAsync([NotNull] IGeneratorSettings generatorSettings)
{
var signaturePath = Path.Combine(Arguments.InputPath, generatorSettings.SpecificationFile);
if (!_cachedProfiles.TryGetValue(signaturePath, out var profiles))
{
profiles = SignatureReader.GetAvailableProfiles(signaturePath).ToList();
_cachedProfiles.TryAdd(signaturePath, profiles);
}
var profileOverrides = OverrideReader
.GetProfileOverrides(generatorSettings.OverrideFiles.ToArray())
.ToList();
var baker = new ProfileBaker(profiles, profileOverrides);
var bakedProfile = baker.BakeProfile
(
generatorSettings.ProfileName,
generatorSettings.Versions,
generatorSettings.BaseProfileName
);
var documentationPath = Path.Combine
(
Arguments.DocumentationPath,
generatorSettings.SpecificationDocumentationPath
);
var docs = DocumentationReader.ReadProfileDocumentation(documentationPath);
var bakedDocs = new DocumentationBaker(bakedProfile).BakeDocumentation(docs);
var languageTypemapPath = Path.Combine(Arguments.InputPath, generatorSettings.LanguageTypemap);
if (!_cachedTypemaps.TryGetValue(languageTypemapPath, out var languageTypemap))
{
using (var fs = File.OpenRead(languageTypemapPath))
{
languageTypemap = new TypemapReader().ReadTypemap(fs);
_cachedTypemaps.TryAdd(languageTypemapPath, languageTypemap);
}
}
var apiTypemapPath = Path.Combine(Arguments.InputPath, generatorSettings.APITypemap);
if (!_cachedTypemaps.TryGetValue(apiTypemapPath, out var apiTypemap))
{
using (var fs = File.OpenRead(apiTypemapPath))
{
apiTypemap = new TypemapReader().ReadTypemap(fs);
_cachedTypemaps.TryAdd(apiTypemapPath, apiTypemap);
}
}
var bakedMap = TypemapBaker.BakeTypemaps(apiTypemap, languageTypemap);
var mapper = new ProfileMapper(bakedMap);
var mappedProfile = mapper.Map(bakedProfile);
var overloadedProfile = OverloadBaker.BakeOverloads(mappedProfile);
var bindingsWriter = new BindingWriter(generatorSettings, overloadedProfile, bakedDocs);
await bindingsWriter.WriteBindingsAsync();
}
public IProfileModel Get(int id)
{
BusinessWorkflowBase.ValidateRequiredID(id);
return(ProfileMapper.MapToModel(ProfilesRepository.Get(id)));
}
public IProfileModel Get(string key)
{
BusinessWorkflowBase.ValidateRequiredKey(key);
return(ProfileMapper.MapToModel(ProfilesRepository.Get(key)));
}
