public void ConvertToDto(ActivityDto dto, ActivityHolder activity)
{
ConvertToModelDto(dto, activity);
dto.Date = activity.Date;
dto.Id = activity.Id;
dto.IsDone = activity.IsDone;
}
public static Activity FromDto(ActivityDto dto)
{
var retVal = new Activity();
retVal.UpdateFromDto(dto);
return(retVal);
}
public static ActivityDto ToDto(Activity model)
{
var retVal = new ActivityDto();
model.UpdateDto(retVal);
return(retVal);
}
public void UpdateFromDto(ActivityDto dto)
{
this.Guid = dto.Guid;
this.Name = dto.Name;
this.ActivityListGuid = dto.ActivityListGuid;
this.GoalGuid = dto.GoalGuid;
this.ActiveDueDate = dto.ActiveDueDate;
if (dto.LeadTime == null)
{
this.LeadTime = null;
}
else
{
this.LeadTime = new DateProjection();
this.LeadTime.UpdateFromDto(dto.LeadTime);
}
if (dto.Recurrence == null)
{
this.Recurrence = null;
}
else
{
this.Recurrence = new DateRecurrence();
this.Recurrence.UpdateFromDto(dto.Recurrence);
}
this.CompletionHistory = new List <ActivityHistoryItem>();
foreach (ActivityHistoryItemDto historyItemDto in dto.CompletionHistory)
{
this.CompletionHistory.Add(ActivityHistoryItem.FromDto(historyItemDto));
}
}
private void ExecuteGoToActivityCommand(ActivityDto activityDto)
{
if (activityDto != null)
{
if (activityDto.ProvenanceKey == 0 && activityDto.VisitStatusWellKnownName != VisitStatus.CheckedIn)
{
_userDialogService.ShowDialog(
"This activity is associated with a Visit that is not 'Checked-In' so the Activity will be in read-only mode.",
string.Empty,
UserDialogServiceOptions.Ok);
}
var viewName = _activityTypeToViewMapper.GetViewNameFromActivityType(activityDto.ActivityType.WellKnownName);
_popupService.ShowPopup(
viewName,
"EditActivity",
string.Empty,
new[]
{
new KeyValuePair <string, string> ("VisitStatusWellKnownName", activityDto.VisitStatusWellKnownName),
new KeyValuePair <string, string> ("IsCurrentActivity", "true"),
new KeyValuePair <string, string> ("ActivityKey", activityDto.Key.ToString()),
new KeyValuePair <string, string> ("PatientKey", activityDto.PatientKey.ToString())
},
true);
}
}
public async Task <ActionResult <object> > Save([FromBody] ActivityDto entity)
{
//var query = ActivityByProjectFilter.For(dto.ProjectId);
//var result = await _mediator.Send(query);
//return result;
return(await Task.FromResult(""));
}
public VAddActivity(string id = "")
{
if (string.IsNullOrEmpty(id))
{
var count = MeetingAppService.Instance.GetNewCode();
ActivityDto = new ActivityDto
{
id = Guid.NewGuid(),
meeting_code = count
};
WTitle = "新建活动";
}
else
{
var meeting = MeetingAppService.Instance.QuerybyId(id);
ActivityDto = new ActivityDto
{
id = meeting.id,
begin_date = meeting.begin_date,
end_date = meeting.end_date,
meeting_name = meeting.meeting_name,
meeting_code = meeting.meeting_code,
is_del = meeting.is_del
};
WTitle = "编辑活动";
}
}
internal IFacadeUpdateResult <ActivityData> SaveActivity(ActivityDto dto)
{
ArgumentValidator.IsNotNull("dto", dto);
FacadeUpdateResult <ActivityData> result = new FacadeUpdateResult <ActivityData>();
IActivityService service = UnitOfWork.GetService <IActivityService>();
Activity instance = RetrieveOrNew <ActivityData, Activity, IActivityService>(result.ValidationResult, dto.Id);
if (result.IsSuccessful)
{
instance.ActivityName = dto.ActivityName;
instance.EmployeeId = dto.EmployeeId;
instance.ContactId = dto.ContactId;
instance.CustomerId = dto.CustomerId;
instance.ActivityTypeId = dto.ActivityTypeId;
instance.Notes = dto.Notes;
instance.StartTime = dto.StartTime;
instance.EndTime = dto.EndTime;
instance.TimeSpent = dto.TimeSpent;
var saveQuery = service.Save(instance);
result.AttachResult(instance.RetrieveData <ActivityData>());
result.Merge(saveQuery);
}
return(result);
}
protected void ucIDetail_ChildListInstanceRowSaving(object sender, InstanceRowSavingEventArgs e)
{
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CRMDataStoreKey))
{
switch ((InstanceTypes)Enum.Parse(typeof(InstanceTypes), e.InstanceType))
{
case InstanceTypes.Activity:
ActivityFacade facade = new ActivityFacade(uow);
ActivityDto instanceDto = e.Instance as ActivityDto;
instanceDto.EmployeeId = CurrentInstance.Id;
// Save data
IFacadeUpdateResult <ActivityData> result = facade.SaveActivity(instanceDto);
e.IsSuccessful = result.IsSuccessful;
if (result.IsSuccessful)
{
// Refresh data in session
CurrentInstance.Activitys = facade.RetrieveActivitysByEmployee(CurrentInstance.Id, new ActivityConverter());
}
else
{
ProcUpdateResult(result.ValidationResult, result.Exception);
}
break;
}
}
}
public async Task <List <Activity> > GetAllAsync(ActivityDto dto, CancellationToken token = default)
{
using (var db = new GuoGuoCommunityContext())
{
var activityList = db.Activities.Where(x => x.IsDeleted == false);
if (dto.ActivitySource == 1)//如果是查询商家活动列表
{
if (!Guid.TryParse(dto.ShopId, out var shopId))
{
throw new NotImplementedException("商店id信息不正确！");
}
activityList = activityList.Where(item => item.ShopId == shopId);
}
else
{
activityList = activityList.Where(item => item.ActivitySource == dto.ActivitySource);
}
if (dto.IsSelectByTime)
{
activityList = activityList.Where(x => x.ActivityBeginTime <= DateTime.Now && x.ActivityEndTime > DateTime.Now);
}
List <Activity> resultList = await activityList.OrderBy(x => x.Money).ToListAsync(token);
return(resultList);
}
}
public ActivityDto SaveActivity(int commentId, int issueId)
{
var issue = issueRepository.GetIssue(issueId, this.userSessionHelper.UserId);
if (issue != null)
{
var activity = new ActivityDto()
{
ObjectId = commentId, ObjectType = "Comment"
};
activity.Description = "Commented";
//activity.NewState = newVersion.Status.Name;
// activity.OldState = previousVersion.Status.Name;
activity.ObjectTitle = issue.Title;
activity.TeamId = userSessionHelper.TeamId;
activity.Actor = new UserDto {
Id = userSessionHelper.UserId
};
var newId = activityRepository.Save(activity);
return(activityRepository.GetActivityItem(newId));
}
return(null);
}
public ActivityDto GetActivityById(int activityId)
{
var activity = _context.Activities
.Include(a => a.Project)
.AsNoTracking() // "cheat" - avoids issue with removing already tracked entity (in RemoveEntity)
.SingleOrDefault(a => a.ActivityID == activityId);
// TODO add better error handling - custom response wrapper(?)
if (activity == null)
{
return(null);
}
// map domain entity (Activity) to dto (ActivityDto)
var activityDto = new ActivityDto
{
ActivityID = activity.ActivityID,
Name = activity.Name,
TimeStart = activity.TimeStart,
TimeEnd = activity.TimeEnd,
TimeTotal = activity.TimeTotal,
ProjectName = activity.Project?.Name
};
return(activityDto);
}
public void Delete(ActivityDto dto)
{
var obj = Mapper.Map <Activity>(dto);
var result = Db.Activity.Find(obj.ActivityId);
base.Delete(result);
}
public virtual async Task <ChargeResponse> Execute(Business.Dtos.Charge newCharge)
{
if (await clientChargeRepository.Get(newCharge.identifier) is ChargeAlreadyExist)
{
return(new ChargeAlreadyExist());
}
await clientActivityService.NotifyNewCharge(new ActivityDto { identifier = newCharge.identifier });
var resultAddCharge = await clientChargeRepository.AddCharge(newCharge);
bool resultAdd = false;
if (resultAddCharge is ChargeResponseOK)
{
resultAdd = true;
}
var identifierDto = new ActivityDto {
identifier = newCharge.identifier, AddResult = resultAdd
};
var result = await clientActivityService.UpdateNotifyCharge(identifierDto);
if (result)
{
return(new ChargeResponseOK());
}
else
{
return(new ChargeResponseKO());
}
}
public HttpResponseMessage Action([FromBody] ActivityDto dto)
{
try
{
dto.CurrUser = emp; // _employeeService.getEmplyByLoginName(RequestContext.Principal.Identity.Name);
var message = ticketService.takeAction(new TicketActivityDataParser(dto));
var values = new
{
status = "success",
message = message
};
return(Request.CreateResponse(HttpStatusCode.OK, values));
}
catch (Exception e)
{
var values = new
{
status = "failed",
message = e.Message
};
return(Request.CreateResponse(HttpStatusCode.InternalServerError, values));
}
}
public async Task <int> AddActivity(ActivityDto requestDto)
{
try
{
var activity = new Activity
{
Name = requestDto.Name,
Description = requestDto.Description,
FkActivityTypeId = requestDto.ActivityTypeId
};
_context.Activity.Add(activity);
_context.SaveChanges();
var stationactivity = new StationActivity
{
FkStationId = requestDto.StationId,
FkActivityId = activity.PkActivityId
};
_context.StationActivity.Add(stationactivity);
return(await Task.FromResult(_context.SaveChanges()));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public int Save(ActivityDto activity)
{
using (var con = new SqlConnection(ConnectionString))
{
con.Open();
var q =
con.Query <int>(
@"INSERT INTO Activity(ObjectID,ObjectType,ActivityDesc,ObjectTitle,OldState,NewState,TeamID,CreatedDate,CreatedByID)
VALUES(@objectId,@objectType,@desc,@title,@oldState,@newState,@teamId,@createdDate,@userId);SELECT CAST(SCOPE_IDENTITY() as int)",
new
{
@objectId = activity.TeamId,
@objectType = activity.ObjectType,
@title = activity.ObjectTitle,
@oldState = activity.OldState,
@newState = activity.NewState,
@desc = activity.Description,
@teamId = activity.TeamId,
@createdDate = DateTime.Now,
@userId = activity.Actor.Id
});
return(q.First());
}
}
public void UpdateDto(ActivityDto dto)
{
dto.Guid = this.Guid;
dto.Name = this.Name;
dto.ActivityListGuid = this.ActivityListGuid;
dto.GoalGuid = this.GoalGuid;
dto.ActiveDueDate = this.ActiveDueDate;
if (this.LeadTime == null)
{
dto.LeadTime = null;
}
else
{
dto.LeadTime = new DateProjectionDto();
this.LeadTime.UpdateDto(dto.LeadTime);
}
if (this.Recurrence == null)
{
dto.Recurrence = null;
}
else
{
dto.Recurrence = new DateRecurrenceDto();
this.Recurrence.UpdateDto(dto.Recurrence);
}
dto.CompletionHistory = new List <ActivityHistoryItemDto>();
foreach (ActivityHistoryItem historyItem in this.CompletionHistory)
{
dto.CompletionHistory.Add(ActivityHistoryItem.ToDto(historyItem));
}
}
public async Task <ActionResult <Activity> > PostActivity(ActivityDto addActivityDto, [FromRoute] string userId)
{
var activity = new Activity();
activity.ActivityName = addActivityDto.ActivityName;
activity.ActivityColorId = addActivityDto.ActivityColorId;
activity.ActivityTypeId = addActivityDto.ActivityTypeId;
activity.DeadLine = Convert.ToDateTime(addActivityDto.DeadLine);
var activityColor = _context.ActivityColor.Where(o => o.ActivityColorId == addActivityDto.ActivityColorId).FirstOrDefault();
activity.ActivityColor = activityColor;
var activityType = _context.ActivityType.Where(o => o.ActivityTypeId == addActivityDto.ActivityTypeId).FirstOrDefault();
activity.ActivityType = activityType;
var user = _context.User.Where(o => o.UserId == Int32.Parse(userId)).FirstOrDefault();
activity.User = user;
activity.UserId = Int32.Parse(userId);
var activityStatus = _context.ActivityStatus.Where(o => o.ActivityStatusName == "NotDone").FirstOrDefault();
activity.ActivityStatus = activityStatus;
activity.ActivityStatusId = activityStatus.ActivityStatusId;
_context.Activity.Add(activity);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetUserActivity", new { userId = userId, activityId = activity.ActivityId }, activity));
}
public void InsertAttachedTo()
{
var proxy = new ActivityProxy();
ActivityDto dto = GetActivityDto();
dto.Owner = ApiUserEmailAddress;
dto.AttachedToType = "Sale";
dto.AttachedToUid = _sale1.Uid;
proxy.Insert(dto);
var result = (ActivityDto)proxy.GetByUid(dto.Uid);
ReflectionTester.AssertAreEqual(dto, result, "LastModified", "UtcLastModified");
dto = GetActivityDto();
dto.Owner = ApiUserEmailAddress;
dto.AttachedToType = "Purchase";
dto.AttachedToUid = _purchase1.Uid;
proxy.Insert(dto);
result = (ActivityDto)proxy.GetByUid(dto.Uid);
ReflectionTester.AssertAreEqual(dto, result, "LastModified", "UtcLastModified");
dto = GetActivityDto();
dto.Owner = ApiUserEmailAddress;
dto.AttachedToType = "Contact";
dto.AttachedToUid = MrSmith.Uid;
proxy.Insert(dto);
result = (ActivityDto)proxy.GetByUid(dto.Uid);
ReflectionTester.AssertAreEqual(dto, result, "LastModified", "UtcLastModified");
}
public void FindAttachedToContact()
{
var proxy = new ActivityProxy();
ActivityDto entity = GetActivityDto();
entity.Owner = ApiUserEmailAddress;
entity.AttachedToType = "Contact";
entity.AttachedToUid = MrSmith.Uid;
proxy.Insert(entity);
List <ActivityDto> apiActivities = proxy.FindList <ActivityDto>(ActivityProxy.ResponseXPath, "Type", "Meeting", "Owner",
ApiUserEmailAddress, "AttachedToType", "Contact",
"AttachedToUid", MrSmith.Uid.ToString());
Assert.AreNotEqual(0, apiActivities.Count);
bool found = false;
foreach (ActivityDto activity in apiActivities)
{
Assert.AreEqual(entity.AttachedToUid, activity.AttachedToUid);
Assert.AreEqual(entity.AttachedToType, activity.AttachedToType);
if (activity.Uid == entity.Uid)
{
found = true;
}
}
if (!found)
{
Assert.Fail("Could not find entity {0} attached to contact.", entity.Uid);
}
proxy.DeleteByUid(entity.Uid);
}
// GET: api/Activities?userId=xyz
public IEnumerable <ActivityDto> GetActivities(String userId)
{
if (userId == "current")
{
userId = User.Identity.GetUserId();
}
return(actSvc.GetActivities(userId).Select(a => ActivityDto.FromActivity(a)));
}
public ArrowGraphEdge(
ActivityDto activityDto,
ArrowGraphVertex source,
ArrowGraphVertex target)
: base(source, target, 1.0)
{
m_Activity = activityDto ?? throw new ArgumentNullException(nameof(activityDto));
ID = m_Activity.Id;
}
public void Find()
{
var proxy = new ActivityProxy();
ActivityDto first = GetActivityDto();
first.Owner = ApiUserEmailAddress;
proxy.Insert(first);
Assert.AreNotEqual(0, first.Uid);
var firstGet = (ActivityDto)proxy.GetByUid(first.Uid);
ReflectionTester.AssertAreEqual(first, firstGet, "LastModified");
ActivityDto second = GetActivityDto();
second.Owner = ApiUserEmailAddress;
second.AttachedToType = "Contact";
second.AttachedToUid = MrSmith.Uid;
proxy.Insert(second);
var secondGet = (ActivityDto)proxy.GetByUid(second.Uid);
ReflectionTester.AssertAreEqual(second, secondGet, "LastModified");
List <ActivityDto> activities = proxy.FindList <ActivityDto>(ActivityProxy.ResponseXPath, "Type", "Meeting");
Assert.AreNotEqual(0, activities.Count);
List <ActivityDto> kazActivities = proxy.FindList <ActivityDto>(ActivityProxy.ResponseXPath, "Type", "Meeting", "Owner",
ApiUserEmailAddress);
Assert.AreNotEqual(0, kazActivities.Count);
// all api/kaz should be part of activities
AssertInList(kazActivities, activities);
// delete
proxy.DeleteByUid(first.Uid);
try
{
firstGet = (ActivityDto)proxy.GetByUid(first.Uid);
}
catch (RestException exception)
{
Assert.AreEqual("RecordNotFoundException", exception.Type);
}
proxy.DeleteByUid(second.Uid);
try
{
secondGet = (ActivityDto)proxy.GetByUid(second.Uid);
}
catch (RestException exception)
{
Assert.AreEqual("RecordNotFoundException", exception.Type);
}
}
private async Task VerifyResult(Business.Dtos.Charge newCharge, ActivityDto activityDto, ChargeActivityServiceApiClient clientActivityService, ChargeResponse result)
{
result.Should().BeOfType <ChargeResponseOK>();
await clientActivityService.Received(1).NotifyNewCharge(Arg.Is <ActivityDto>(item => item.identifier == activityDto.identifier));
await clientChargeRepository.Received(1).AddCharge(newCharge);
await clientActivityService.Received(1).UpdateNotifyCharge(Arg.Is <ActivityDto>(item => item.identifier == activityDto.identifier && item.AddResult == activityDto.AddResult));
}
public async Task <ActivityDtoResponse> CreateActivity(ActivityDto activity)
{
Activity newActivity = await _activityRepository.CreateActivityAsync(new Activity()
{
Description = activity.Description, UserId = activity.UserId
});
return(newActivity.MapToDtoResponse());
}
private static ActivityDto GivenAnActivityDto()
{
var identifier = "anyIdentifier";
var addResult = true;
var identifierDto = new ActivityDto {
identifier = identifier, AddResult = addResult
};
return(identifierDto);
}
public void ConvertToDto(ActivityDto dto, WActivity wActivity, IEnumerable <TaskDto> tasks)
{
ConvertToDto(dto, wActivity);
var task = tasks.Where(x => x.Id == wActivity.Id).SingleOrDefault();
if (task != null)
{
dto.Task = task;
}
}
public void ConvertFromDto(WActivity wActivity, ActivityDto dto, IEnumerable <WTask> tasks)
{
ConvertFromDto(wActivity, dto);
var wtask = tasks.Where(x => x.Id == dto.Id).SingleOrDefault();
if (wtask != null)
{
wActivity.WTask = wtask;
}
}
public async Task <ActionResult <Activity> > PostActivity(ActivityDto activityDto)
{
Activity activity = _mapper.Map <Activity>(activityDto);
activity = await _activityService.createActivity(activity);
return(CreatedAtAction("GetActivity", new { id = activity.Id }, activity));
}
public Activity(ActivityDto dto)
{
_dto = dto;
}
