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