public int CreateActivity(int editionId, ActivityModel activityModel)
{
var isValidData = ValidateNewActivityData(activityModel, editionId);
if (!isValidData)
{
return(0);
}
var status = _unitOfWork.ActivityStatusRepository.GetById((int)ActivityStatusEnum.PEN);
activityModel.StatusId = status.Id;
var activity = ActivityMapper.Map(activityModel);
activity.EditionId = editionId;
activity.CreateDateTime = DateTime.Now;
// Add logging
try
{
_unitOfWork.ActivityRepository.Insert(activity);
_unitOfWork.ActivityRepository.Save();
}
catch (Exception e)
{
return(0);
}
return(1);
}
public List <ActivityModel> GetLastThreeActivities(int edition)
{
var activeStatus = _unitOfWork.ActivityStatusRepository
.GetById((int)ActivityStatusEnum.ACT);
var currentEdition = _unitOfWork.EditionRepository
.GetById(edition);
if (currentEdition == null || activeStatus == null)
{
return(null);
}
var activities = _unitOfWork.ActivityRepository
.GetLastThreeActivities(activeStatus.Id, currentEdition.Id, ACTIVITIESINHOME);
if (activities == null || activities.Count == 0)
{
return(null);
}
var models = new List <ActivityModel>();
foreach (var act in activities)
{
models.Add(ActivityMapper.Map(act));
}
return(models);
}
public void DeleteActivity(MappedActivity activity)
{
Activity act = ActivityMapper.MapActivityToDB(activity);
context.Acivities.Attach(act);
context.Acivities.Remove(act);
context.SaveChanges();
}
public MappedActivity ModifActivity(MappedActivity activity)
{
Activity act = ActivityMapper.MapActivityToDB(activity);
context.Entry(act).State = EntityState.Modified;
context.SaveChanges();
act = context.Acivities.SingleOrDefault(a => a.ID == activity.ID);
return(ActivityMapper.MapActivityFromDB(act));
}
public MappedActivity AddActivity(MappedActivity activity)
{
Activity act = ActivityMapper.MapActivityToDB(activity);
act.CreatedTime = DateTime.Now;
act = context.Acivities.Add(act).Entity;
context.SaveChanges();
return(ActivityMapper.MapActivityFromDB(act));
}
public bool Update(ActivityModel activityModel)
{
return(LogIfOperationFailed(() =>
{
Activity activity = ActivityMapper.ConvertModelToEntity(activityModel);
_unitOfWork.ActivityRepository.InsertOrUpdate(activity);
_unitOfWork.Commit();
return true;
}, Resources.ExceptionUpdateActivity, activityModel.Name));
}
public IEnumerable <MappedActivity> GetActivities()
{
var activities = context.Acivities;
List <MappedActivity> ret = new List <MappedActivity>();
foreach (Activity a in activities)
{
ret.Add(ActivityMapper.MapActivityFromDB(a));
}
return(ret);
}
private void AppendActivity(IFieldDataResultsAppender appender, ParsedData parsedData,
FieldVisitInfo visitInfo, ILog logger)
{
var visitInterval = new DateTimeInterval(visitInfo.StartDate, visitInfo.EndDate);
var dischargeActivity = new ActivityMapper(parsedData, visitInterval)
.GetDischargeActivity();
logger.Info($"Got discharge activity for {visitInfo.StartDate:s}@{visitInfo.LocationInfo.LocationIdentifier}.");
appender.AddDischargeActivity(visitInfo, dischargeActivity);
}
public List <ActivityDto> GetPendingActivities(int editionId)
{
var penActivities = _activityDomainService.GetPendingActivities(editionId);
var result = new List <ActivityDto>();
foreach (var act in penActivities)
{
result.Add(ActivityMapper.Map(act));
}
return(result);
}
public ActivityModel GetActivity(int id)
{
return(LogIfOperationFailed(() =>
{
var activityEntity = _unitOfWork.ActivityRepository.Find(id);
//ToDo:Need to implement Automapper
ActivityModel activityModel = ActivityMapper.ConvertEntityToModel(activityEntity);
return activityModel;
}, Resources.ExceptionGetActivity, id));
}
public List <ActivityModel> GetAllActivities()
{
return(LogIfOperationFailed(() =>
{
var activityEntity = _unitOfWork.ActivityRepository.GetAll;
var activityModelList = new List <ActivityModel>();
// ToDo:Need to implement Automapper
activityEntity
.ToList()
.ForEach(m => { activityModelList.Add(ActivityMapper.ConvertEntityToModel(m)); });
return activityModelList;
}, Resources.ExceptionGetForAllActivitys));
}
public UserImportDataProcessor(
IGooglePlusPeopleProvider peopleProvider,
IGooglePlusActivitiesProvider activitiesProvider,
GoogleDataManager dataManager,
RedisDataManager redisDataManager)
{
this.peopleProvider = peopleProvider;
this.activitiesProvider = activitiesProvider;
this.dataManager = dataManager;
this.redisDataManager = redisDataManager;
userMapper = new UserMapper();
activityMapper = new ActivityMapper();
}
public void GetDischargeActivity_ReturnsCorrectDischargeAndGageHeights()
{
var parsedActivity = new ActivityMapper(_parsedData, _visitInterval).GetDischargeActivity();
Assert.That(parsedActivity.Discharge.Value, Is.EqualTo(1190.0d));
Assert.That(parsedActivity.GageHeightMeasurements.Count, Is.EqualTo(4));
var firstGageMeasurement = parsedActivity.GageHeightMeasurements.First();
Assert.That(firstGageMeasurement.GageHeight.Value, Is.EqualTo(8.11));
Assert.That(firstGageMeasurement.MeasurementTime,
Is.EqualTo(_visitInterval.Start.Add(TimeSpan.Parse("11:50"))));
}
public int UpdateActivity(ActivityModel activityModel)
{
var activity = ActivityMapper.Map(activityModel);
try
{
_unitOfWork.ActivityRepository.Update(activity);
_unitOfWork.ActivityRepository.Save();
}
catch (Exception)
{
return(0);
}
return(1);
}
public List <ActivityDto> GetLastThreeActivities(int editionId)
{
var activities = _activityDomainService.GetLastThreeActivities(editionId);
if (activities == null || activities.Count == 0)
{
return(null);
}
var dtos = new List <ActivityDto>();
foreach (var act in activities)
{
dtos.Add(ActivityMapper.Map(act));
}
return(dtos);
}
public ActivityFilteredResultModel GetActiveActivitiesFiltered(int type, int edition,
string title, int currentPage)
{
int activitiesPerPage = 10;
var activeStatus = _unitOfWork.ActivityStatusRepository
.GetById((int)ActivityStatusEnum.ACT);
var currentEdition = _unitOfWork.EditionRepository
.GetById(edition);
if (currentEdition == null || activeStatus == null)
{
return(null);
}
int skipByPagination = (currentPage - 1) * activitiesPerPage;
var activities = _unitOfWork.ActivityRepository
.GetActiveActivitiesFiltered(activeStatus.Id, type, currentEdition.Id,
title, skipByPagination, activitiesPerPage);
var models = new List <ActivityModel>();
foreach (var act in activities)
{
models.Add(ActivityMapper.Map(act));
}
int totalActivities = _unitOfWork.ActivityRepository
.GetTotalActivities(activeStatus.Id, type, currentEdition.Id, title);
double actsPerPage = totalActivities / activitiesPerPage;
var totalPages = (int)Math.Ceiling(actsPerPage);
var result = new ActivityFilteredResultModel
{
Activities = models,
CurrentPage = currentPage,
TotalPages = totalPages
};
return(result);
}
public List <ActivityModel> GetPendingActivities(int editionId)
{
var pendingStatus = _unitOfWork.ActivityStatusRepository
.GetById((int)ActivityStatusEnum.PEN);
if (pendingStatus == null)
{
return(null);
}
var activities = _unitOfWork.ActivityRepository
.GetActivitiesByStatus(editionId, pendingStatus.Id);
var models = new List <ActivityModel>();
foreach (var act in activities)
{
models.Add(ActivityMapper.Map(act));
}
return(models);
}
private ManualGaugingDischargeSection GetParsedDischargeSection(ParsedData parsedData)
{
var parsedActivity = new ActivityMapper(parsedData, _visitInterval).GetDischargeActivity();
return((ManualGaugingDischargeSection)parsedActivity.ChannelMeasurements.First());
}
public MappedActivity GetActivityById(long id)
{
Activity activity = context.Acivities.SingleOrDefault(x => x.ID == id);
return(ActivityMapper.MapActivityFromDB(activity));
}
public int UpdateActivity(ActivityDto activityDto)
{
var activityModel = ActivityMapper.Map(activityDto);
return(_activityDomainService.UpdateActivity(activityModel));
}
public int CreateActivity(int editionId, ActivityDto activityDto)
{
var activityModel = ActivityMapper.Map(activityDto);
return(_activityDomainService.CreateActivity(editionId, activityModel));
}
