public HttpResponseMessage QuoteRequestEdit(QuoteRequestUpdateRequest model)
        {
            if (!ModelState.IsValid)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
            }

            bool isSuccessful = _QuoteRequestService.UpdateQuoteRequest(model);

            var qrUserId = UserService.GetCurrentUserId();

            var userProfile = _AdminService.ProfileGetByUserId(qrUserId);

            var qrCompanyId = userProfile.CompanyId;

            ActivityService activityService = new ActivityService();

            ActivityRequest activity = new ActivityRequest();

            activity.UserId       = qrUserId;
            activity.CompanyId    = qrCompanyId;
            activity.PrimaryId    = model.QrId.ToString();
            activity.ActivityType = ActivityType.QuoteRequest;
            activity.ActionType   = ActionType.Updated;
            activity.Name         = model.Name;

            activityService.ActivityInsert(activity);

            ItemResponse <bool> response = new ItemResponse <bool> {
                Item = isSuccessful
            };

            return(Request.CreateResponse(HttpStatusCode.OK, response));
        }
        /// <summary>
        /// Change Activity informations.
        /// </summary>
        /// <param name="request">activity request.</param>
        /// <returns>Activity message.</returns>
        public ActivityMessage UpdateActivity(ActivityRequest request)
        {
            ActivityMessage message = new ActivityMessage();

            try
            {
                request.FindActivityDto = FindActivityDto.ActivityId;
                ActivityResponsePivot response = _serviceActivity.FindActivities(request.ToPivot());
                if (response?.ActivityPivot != null)
                {
                    _serviceActivity.UpdateActivity(request.ToPivot());
                    message.OperationSuccess = true;
                }
                else
                {
                    message.ErrorMessage     = ActivityMessageResource.NotFoundActivity;
                    message.ErrorType        = ErrorType.FunctionalError;
                    message.OperationSuccess = false;
                }
            }
            catch (Exception e)
            {
                message.ErrorType    = ErrorType.TechnicalError;
                message.ErrorMessage = e.Message;
            }
            return(message);
        }
Esempio n. 3
0
        /// <summary>
        /// 查询培育任务
        /// </summary>
        /// <param name="logcallrequest"></param>
        /// <returns></returns>
        public async Task <QueryResult <CrmEntity> > GetActivityList(ActivityRequest activityrequest)
        {
            try
            {
                var userInfo    = ContextContainer.GetValue <UserInfo>(ContextExtensionTypes.CurrentUserInfo);
                var ProxyUserId = userInfo != null ? userInfo.systemuserid : null;

                var fetchString = _onlyLeadRepository.GetActivityList(activityrequest);

                var fetchXdoc    = XDocument.Parse(fetchString);
                var fetchRequest = new CrmRetrieveMultipleFetchRequestMessage()
                {
                    EntityName  = "mcs_activity",
                    FetchXml    = fetchXdoc,
                    ProxyUserId = ProxyUserId
                };
                var fetchResponse = await _crmService.Execute(fetchRequest);

                var fetchResponseResult = fetchResponse as CrmRetrieveMultipleFetchResponseMessage;

                var queryResult = new QueryResult <CrmEntity>();
                queryResult.Results     = fetchResponseResult.Value.Results;
                queryResult.CurrentPage = activityrequest.PageIndex;
                queryResult.TotalCount  = fetchResponseResult.Value.Count;
                return(queryResult);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        } // end of PossibleChangeWard

        #endregion

        //--------------------------------------------------------------------------------------------------
        // Custom Methods
        //--------------------------------------------------------------------------------------------------

        #region ChooseDoctor

        private EntityDoctor ChooseDoctor(EntityPatient patient, ActivityRequest request)
        {
            IReadOnlyList <EntityDoctor> doctors = ControlledDoctors;

            foreach (EntityDoctor doctor in doctors)
            {
                if ((doctor.IsWaiting() || doctor.IsInOnlyActivity("ActivityInpatientDoctorOrganizationalWork")) &&
                    !doctor.BlockedForDispatching)
                {
                    return(doctor);
                }
            } // end foreach

            if (request is RequestInpatientActivity && ((RequestInpatientActivity)request).Activity == "ActivityInpatientEmergencyTreatment")
            {
                foreach (EntityDoctor doctor in doctors)
                {
                    if (doctor.IsWaitingOrPreEmptable())
                    {
                        return(doctor);
                    }
                } // end foreach
            }     // end if

            return(null);
        } // end of ChooseDoctor
Esempio n. 5
0
        /// <summary>
        /// 列表
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task <QueryResult <CrmEntity> > getlist(ActivityRequest request)
        {
            var userInfo = ContextContainer.GetValue <UserInfo>(ContextExtensionTypes.CurrentUserInfo);

            try
            {
                var fetchXdoc    = _Repository.GetListFetchXml(request);
                var fetchRequest = new CrmRetrieveMultipleFetchRequestMessage()
                {
                    EntityName  = "mcs_activity",
                    FetchXml    = fetchXdoc.Result,
                    ProxyUserId = userInfo?.systemuserid
                };
                var fetchResponse = await _crmService.Execute(fetchRequest);

                var fetchResponseResult = fetchResponse as CrmRetrieveMultipleFetchResponseMessage;
                var queryResult         = new QueryResult <CrmEntity>();
                queryResult.Results     = fetchResponseResult.Value.Results;
                queryResult.CurrentPage = request.PageSize;
                queryResult.TotalCount  = 0;
                return(queryResult);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Esempio n. 6
0
 /// <summary>
 /// From Activity Request to Activity Request pivot.
 /// </summary>
 /// <param name="request">the request to assemble.</param>
 /// <returns>Activity Request pivot result.</returns>
 public static ActivityRequestPivot ToPivot(this ActivityRequest request)
 {
     return(new ActivityRequestPivot
     {
         FindActivityPivot = Utility.EnumToEnum <FindActivityDto, FindActivityPivot>(request.FindActivityDto),
         ActivityPivot = request.ActivityDto.ToPivot()
     });
 }
Esempio n. 7
0
 public static Activity ToActivity(this ActivityRequest activityRequest)
 {
     return(new Activity
     {
         LeadId = activityRequest.LeadId,
         Type = ParseEnum <ActivityType>(activityRequest.Type),
     });
 }
Esempio n. 8
0
        public virtual async Task <HttpResponseMessage> Post([FromBody] Microsoft.Bot.Connector.Activity activity)
        {
            try
            {
                if (activity != null && activity.GetActivityType() == ActivityTypes.Message)
                {
                    // Get and process
                    IMessageActivity message = activity.AsMessageActivity();

                    ActivityRequest request = new ActivityRequest(
                        recipient: message.Recipient.Name,
                        text: message.Text,
                        from: message.From.Name,
                        fromId: message.From.Id,
                        channelId: message.ChannelId,
                        conversationId: message.Conversation.Id,
                        isGroup: message.Conversation.IsGroup,
                        attachments: message.Attachments?.Select(
                            attachment => new AttachmentRequest(attachment.ContentUrl, attachment.ContentType)
                            ));

                    ActivityResponse response = await this.ActivityProcessor.ProcessActivityAsync(this.Store, request).ConfigureAwait(false);

                    // Reply (on a new network connection) back.
                    Microsoft.Bot.Connector.Activity reply = activity.CreateReply();
                    reply.Text = response.Text;
                    foreach (AttachmentResponse attachment in response.Attachments)
                    {
                        reply.Attachments.Add(new Attachment(attachment.ContentType, attachment.ContentUrl, null, attachment.Name));
                    }

                    // Send it either as a group message or individually, depending on how we received the message,
                    using (ConnectorClient connector = new ConnectorClient(new Uri(activity.ServiceUrl)))
                    {
                        if (message.Conversation.IsGroup.HasValue && message.Conversation.IsGroup.Value)
                        {
                            await connector.Conversations.SendToConversationAsync(reply);
                        }
                        else
                        {
                            await connector.Conversations.ReplyToActivityAsync(reply);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                using (ConnectorClient connector = new ConnectorClient(new Uri(activity.ServiceUrl)))
                {
                    Microsoft.Bot.Connector.Activity reply = activity.CreateReply();
                    reply.Text = ex.Message + " " + ex.StackTrace;
                    await connector.Conversations.ReplyToActivityAsync(reply);
                }
            }

            // We always accept the message and send the response using the bot framework on another channel.
            return(new HttpResponseMessage(HttpStatusCode.Accepted));
        }
Esempio n. 9
0
        public async Task <List <extension.Activities> > GetActivities(ActivityRequest req, int selfId)
        {
            //TODO: Проект убрать после отладки
            var workItems = await _azureDevOpsService.GetChildWorkItems(req.Project ?? "ShtormDemoProject(Agile)", selfId);

            int[] wiIds      = workItems.Select(x => x.Id).Where(x => x != null).Cast <int>().ToArray();
            var   timesheets = await _timesheetRepository.GetTimesheets(wiIds);

            return(timesheets.GroupingActivitiesDuration().ToList());
        }
Esempio n. 10
0
        private void RequestSuggestion_Impl(ActivityRequest activityRequest)
        {
            SuggestedMetric_Metadata result = this.owner.ChooseExperimentOption(activityRequest);

            if (result.Content != null)
            {
                this.Suggestion = result.Content;
                this.owner.UpdateStatus();
            }
        }
Esempio n. 11
0
        public IActionResult Create([FromBody] ActivityRequest request)
        {
            var activity = Mapper.Map <Activity>(request);

            activityRepository.CreateActivity(activity);

            var response = Mapper.Map <ActivityResponse>(activity);

            return(Ok(response));
        }
        public SuggestedMetric_Metadata ChooseExperimentOption(ActivityRequest activityRequest)
        {
            SuggestedMetric_Metadata result = this.activityRecommender.ChooseExperimentOption(activityRequest, this.Suggestions);

            if (result.Error != "")
            {
                this.UpdateStatus(result.Error);
            }
            return(result);
        }
Esempio n. 13
0
        public IActionResult Update(Guid id, [FromBody] ActivityRequest request)
        {
            var activity = activityRepository.GetActivity(id);

            Mapper.Map(request, activity);
            activityRepository.UpdateActivity(activity);

            var response = Mapper.Map <ActivityResponse>(activity);

            return(Ok(response));
        }
Esempio n. 14
0
        public IActionResult Post([FromHeader] string eventId, [FromBody] ActivityRequest activity)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            _activityService.Create(activity, eventId);


            return(Ok());
        }
Esempio n. 15
0
        public async Task <IActionResult> AddActivity([FromBody] ActivityRequest request)
        {
            try
            {
                var activity = await _activityService.Create(request.ToActivity());

                return(Created(nameof(GetActivity), activity.ToActivityResponse()));
            }
            catch (Exception e)
            {
                return(BadRequest(new ErrorPayload(1, e.Message)));
            }
        }
Esempio n. 16
0
        public void Test_ActivityRequest()
        {
            // Ensures that we can serialize and deserialize activity request messages.

            ActivityRequest message;

            using (var stream = new MemoryStream())
            {
                // Empty message.

                message = new ActivityRequest();

                stream.SetLength(0);
                stream.Write(message.SerializeAsBytes(ignoreTypeCode: true));
                stream.Seek(0, SeekOrigin.Begin);

                message = ProxyMessage.Deserialize <ActivityRequest>(stream, ignoreTypeCode: true);
                Assert.NotNull(message);
                Assert.Equal(0, message.ClientId);
                Assert.Equal(0, message.RequestId);
                Assert.Equal(0, message.ContextId);

                // Round-trip

                message.ClientId  = 444;
                message.RequestId = 555;
                message.ContextId = 666;

                Assert.Equal(444, message.ClientId);
                Assert.Equal(555, message.RequestId);
                Assert.Equal(666, message.ContextId);

                stream.SetLength(0);
                stream.Write(message.SerializeAsBytes(ignoreTypeCode: true));
                stream.Seek(0, SeekOrigin.Begin);

                message = ProxyMessage.Deserialize <ActivityRequest>(stream, ignoreTypeCode: true);
                Assert.NotNull(message);
                Assert.Equal(444, message.ClientId);
                Assert.Equal(555, message.RequestId);
                Assert.Equal(666, message.ContextId);

                // Clone()

                message = (ActivityRequest)message.Clone();
                Assert.NotNull(message);
                Assert.Equal(444, message.ClientId);
                Assert.Equal(555, message.RequestId);
                Assert.Equal(666, message.ContextId);
            }
        }
Esempio n. 17
0
        public async Task <NewtonsoftJsonActionResult <QueryResult <CrmEntity> > > GetMyActivityList(string seachkey = "", string systemuserid = "", int pageSize = 10, int page = 1, string sort = "", int mcs_activitystatus = -1)
        {
            var request = new ActivityRequest()
            {
                SearchKey          = seachkey,
                PageIndex          = page,
                PageSize           = pageSize,
                mcs_activitystatus = mcs_activitystatus,
                UserId             = systemuserid
            };

            var list = await app.GetActivityList(request);

            return(list);
        }
        public async Task <ActionResult> Edit(string id, ActivityRequest activityRequest)
        {
            try
            {
                await _eventManagerApi.UpdateActivityOfAnEventAsync(TempData.Peek("EventId").ToString(), id, activityRequest);

                return(RedirectToAction(nameof(Index), "Activity", new { id = TempData.Peek("EventId").ToString() }));
            }
            catch
            {
                await CreateStageDropDown();
                await CreateSpeakerDropDown();

                return(View());
            }
        }
Esempio n. 19
0
        /// <summary>
        /// Create new Activity
        /// </summary>
        /// <param name="request">activity request.</param>
        /// <returns>Activity message.</returns>
        public ActivityMessage CreateActivity(ActivityRequest request)
        {
            ActivityMessage message = new ActivityMessage();

            try
            {
                message = _serviceActivity.CreateActivity(request.ToPivot()).ToMessage();
                message.OperationSuccess = true;
            }
            catch (Exception e)
            {
                message.ErrorType    = ErrorType.TechnicalError;
                message.ErrorMessage = e.Message;
            }
            return(message);
        }
Esempio n. 20
0
        private void Suggest(ActivityRequestOptimizationProperty optimizationProperty)
        {
            ActivityRequest activityRequest = new ActivityRequest(this.categoryBox.Activity, this.atLeastAsFunAs_activity, DateTime.Now, optimizationProperty);

            activityRequest.NumOptionsRequested = this.numChoicesPerSuggestion;
            if (this.atLeastAsFunAs_activity != null)
            {
                DateTime      startDate                 = activityRequest.Date;
                DateTime      hypotheticalEndDate       = this.engine.GuessParticipationEndDate(this.atLeastAsFunAs_activity, startDate);
                Participation hypotheticalParticipation = new Participation(startDate, hypotheticalEndDate, activityRequest.ActivityToBeat);
                hypotheticalParticipation.Hypothetical = true;

                Rating userPredictedRating = this.specify_AtLeastAsFunAs_Layout.EstimatedRating_Box.GetRelativeRating(this.engine, hypotheticalParticipation);
                activityRequest.UserPredictedRating = userPredictedRating;
            }
            this.RequestSuggestion.Invoke(activityRequest);
        }
Esempio n. 21
0
        public async Task <ActivityResult> GetResidentActivity(ActivityRequest activityRequest)
        {
            LoginRequest loginRequest = new LoginRequest()
            {
                userName = _configuration.GetSection("ApplicationSettings")["UserName"],
                password = _configuration.GetSection("ApplicationSettings")["Password"]
            };
            LoginResponse loginResponse = await _authenticationService.Login(loginRequest);

            //var result = await _apiManager.PostExternalAsync<ActivityResult>("report", "GetResidentActivity", activityRequest, loginResponse.token);
            var response = await Task.Run(async() => {
                var result = await PostAsync(activityRequest, loginResponse.token);
                return(result);
            });

            return(response);
        }
Esempio n. 22
0
        public void Create(ActivityRequest element, string eventId)
        {
            Activity activity = new Activity
            {
                ActivityId  = Guid.NewGuid().ToString(),
                StartDate   = element.StartDate,
                EndDate     = element.EndDate,
                Description = element.Description,
                EventId     = eventId,
                Name        = element.Name,
                SpeakerId   = element.SpeakerId,
                StageId     = element.StageId
            };

            _botEventManagementContext.Activity.Add(activity);
            _botEventManagementContext.SaveChanges();
        }
Esempio n. 23
0
        public async Task <ApiResponse> Create(ActivityRequest model)
        {
            var activity = new Activity(model.Name.ToLower(), model.Description, model.Location, model.Open, model.Close);

            try
            {
                await _bookingDbContext.Activities.AddAsync(activity);

                await _bookingDbContext.SaveChangesAsync();
            }
            catch (Exception e)
            {
                return(new ApiResponse(400, "Could not create activity"));
            }

            return(new ApiResponse(201, "Activity Created"));
        }
Esempio n. 24
0
        public void UpdateActivity(ActivityRequest request)
        {
            var activity = GetActivities().First(a => a.Id == request.Id);

            activity.Name                       = request.Name;
            activity.ProcessId                  = request.ProcessId;
            activity.Units                      = request.Units;
            activity.SafeProductivityRate       = request.SafeProductivityRate;
            activity.AggressiveProductivityRate = request.AggressiveProductivityRate;
            activity.DurationFunction           = request.DurationFunction;
            activity.UnitDelta                  = request.UnitDelta;
            activity.StartToFinish              = request.StartToFinish;
            activity.Dependencies               = request.Dependencies;
            activity.Duration                   = request.Duration;
            activity.AggressiveDuration         = request.AggressiveDuration;
            activity.inputProdRate              = request.InputProdRate;
            activity.Section                    = request.Section;
            _repository.UpdateActivity(activity);
        }
Esempio n. 25
0
 public void AddActivity(ActivityRequest request)
 {
     _repository.AddActivity(new Activity
     {
         Name                       = request.Name,
         ProcessId                  = request.ProcessId,
         Units                      = request.Units,
         SafeProductivityRate       = request.SafeProductivityRate,
         AggressiveProductivityRate = request.AggressiveProductivityRate,
         DurationFunction           = request.DurationFunction,
         UnitDelta                  = request.UnitDelta,
         StartToFinish              = request.StartToFinish,
         Dependencies               = request.Dependencies,
         Duration                   = request.Duration,
         AggressiveDuration         = request.AggressiveDuration,
         inputProdRate              = request.InputProdRate,
         Section                    = request.Section
     });
 }
        /// <inheritdoc />
        public async Task <ActivityResponse> ProcessActivityAsync(IStore store, ActivityRequest request)
        {
            ConversationResponse <T> response;

            if (!(await store.ExistsAsync(this.SubContainer, request.ConversationId)))
            {
                response = await this.StartConversationAsync(store, request).ConfigureAwait(false);
            }
            else
            {
                T priorConversation = await store.GetAsync <T>(this.SubContainer, request.ConversationId).ConfigureAwait(false);

                response = await this.ContinueConversationAsync(store, request, priorConversation).ConfigureAwait(false);
            }

            await store.CreateOrUpdateAsync(this.SubContainer, request.ConversationId, response.ConversationContext).ConfigureAwait(false);

            return(response.SpecificResponse);
        }
Esempio n. 27
0
        /// <summary>
        /// 列表获取
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task <XDocument> GetListFetchXml(ActivityRequest request)
        {
            return(await Task <XDocument> .Run(() =>
            {
                var filterStr = "";
                if (!string.IsNullOrEmpty(request.SearchKey))
                {
                    filterStr += $@"  <filter type='or'>
                       <condition attribute='mcs_name' operator='like' value='%{request.SearchKey}%' />
                       <condition attribute='mcs_activitystatus' operator='eq' value='{request.mcs_activitystatus}' /> 
                     </filter>/>
                    ";
                }
                var fetchXml = $@"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'
                   count='{request.PageSize}' page='{request.PageIndex}'>
  <entity name='mcs_activity'>
  <attribute name='mcs_name' />
    <attribute name='createdon' />
    <attribute name='mcs_importantlevel' />
    <attribute name='mcs_endtime' />
    <attribute name='mcs_activitystatus' />
    <attribute name='ownerid' />
    <attribute name='mcs_nextfollowuptime' />
    <attribute name='mcs_nextfollowupcontent' />
    <attribute name='mcs_thisfollowupcontent' />
    <attribute name='mcs_onlyleadid' />
    <attribute name='mcs_activityid' />
    <order attribute='createdon' descending='true' />
    <filter type='and'>
      <condition attribute='statecode' operator='eq' value='0' /> 
{filterStr}
    </filter> 
   <link-entity name='mcs_onlylead' from='mcs_onlyleadid' to='mcs_onlyleadid' visible='false' link-type='outer' >
      <attribute name='mcs_mobilephone' alias='mobilephone'/>
      <attribute name='mcs_name' alias='onlyleadname'/>
    </link-entity>
  </entity>
</fetch>";
                return XDocument.Parse(fetchXml);
            }));
        }
        public HttpResponseMessage QuoteRequestInsert(QuoteRequestInsertRequest model)
        {
            if (!ModelState.IsValid)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
            }

            //QuoteRequestInsertRequest newQuoteRequest = new QuoteRequestInsertRequest();

            model.UserId = UserService.GetCurrentUserId();

            var userProfile = _AdminService.ProfileGetByUserId(model.UserId);

            model.CompanyId = userProfile.CompanyId;



            int quoteId = _QuoteRequestService.InsertQuoteRequest(model);

            ActivityService activityService = new ActivityService();

            ActivityRequest activity = new ActivityRequest();

            activity.UserId       = model.UserId;
            activity.CompanyId    = model.CompanyId;
            activity.PrimaryId    = quoteId.ToString();
            activity.ActivityType = ActivityType.QuoteRequest;
            activity.ActionType   = ActionType.Created;
            activity.Name         = model.Name;

            activityService.ActivityInsert(activity);



            ItemResponse <int> response = new ItemResponse <int> {
                Item = quoteId
            };

            return(Request.CreateResponse(HttpStatusCode.OK, response));
        }
Esempio n. 29
0
        public void Update(ActivityRequest element, string eventId)
        {
            var activity = _botEventManagementContext.Activity.Where(x => x.ActivityId == element.ActivityId && x.EventId == eventId).FirstOrDefault();

            if (element.StartDate != DateTime.MinValue && element.StartDate != activity.StartDate)
            {
                activity.StartDate = element.StartDate;
            }

            if (element.EndDate != DateTime.MinValue && element.EndDate != activity.EndDate)
            {
                activity.EndDate = element.EndDate;
            }

            if (element.Description != activity.Description)
            {
                activity.Description = element.Description;
            }

            if (element.Name != activity.Name)
            {
                activity.Name = element.Name;
            }

            if (element.SpeakerId != activity.SpeakerId)
            {
                activity.SpeakerId = element.SpeakerId;
            }

            if (element.StageId != activity.StageId)
            {
                activity.StageId = element.StageId;
            }

            _botEventManagementContext.Entry(activity).State = EntityState.Modified;
            _botEventManagementContext.SaveChanges();
        }
Esempio n. 30
0
        public async Task <ActionResult <ActivityResult> > GetResidentActivity(ActivityRequest activityRequest)
        {
            var result = await _reportingService.GetResidentActivity(activityRequest);

            return(result);
        }