public IActionResult CreateNewActvity([FromBody] CreateActivityRequest requestModel)
{
try
{
var validationResult = requestModel.Validate();
if (validationResult.Any())
{
return(BadRequest(validationResult));
}
CreateNewActivity newActivityModel = new CreateNewActivity()
{
ActivityName = requestModel.ActivityName,
ActivityType = requestModel.ActivityType,
Message = requestModel.Message,
ResourceType = requestModel.ResourceType
};
var activityId = MongoConnector.CreateNewActivity(newActivityModel);
return(Ok($"ActivityId:{activityId}"));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
internal virtual CreateActivityResponse CreateActivity(CreateActivityRequest request)
{
var marshaller = new CreateActivityRequestMarshaller();
var unmarshaller = CreateActivityResponseUnmarshaller.Instance;
return(Invoke <CreateActivityRequest, CreateActivityResponse>(request, marshaller, unmarshaller));
}
public async Task CreateAsync(CreateActivityRequest request)
{
var costs = request.Costs
.Select(c =>
{
var parameters = c.Parameters
.Select(p => new ActivityParameterEntity
{
VariableName = p.VariableName,
Description = p.Description
})
.ToArray();
return(new ActivityCostEntity
{
Kind = c.Kind,
JexlExpression = c.JexlExpression,
Parameters = parameters
});
})
.ToArray();
var entity = new ActivityEntity
{
Name = request.Name,
DescriptionMarkdown = request.DescriptionMarkdown,
ComplicationMarkdown = request.ComplicationMarkdown,
Costs = costs
};
await(await _container).CreateItemAsync(await _entityMutator.CreateMetadataAsync(entity, request.SharedWith));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateActivity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateActivity operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/states-2016-11-23/CreateActivity">REST API Reference for CreateActivity Operation</seealso>
public virtual Task <CreateActivityResponse> CreateActivityAsync(CreateActivityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new CreateActivityRequestMarshaller();
var unmarshaller = CreateActivityResponseUnmarshaller.Instance;
return(InvokeAsync <CreateActivityRequest, CreateActivityResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public CreateActivityModel CreateActivityModel(CreateActivityRequest createActivityRequest)
{
var roundUp = DateTime.Now.RoundUp();
return(new CreateActivityModel {
StartAt = roundUp, EndAt = roundUp.AddHours(1)
});
}
/// <summary>
/// Initiates the asynchronous execution of the CreateActivity operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateActivity operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/states-2016-11-23/CreateActivity">REST API Reference for CreateActivity Operation</seealso>
public virtual Task <CreateActivityResponse> CreateActivityAsync(CreateActivityRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateActivityRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateActivityResponseUnmarshaller.Instance;
return(InvokeAsync <CreateActivityResponse>(request, options, cancellationToken));
}
internal virtual CreateActivityResponse CreateActivity(CreateActivityRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateActivityRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateActivityResponseUnmarshaller.Instance;
return(Invoke <CreateActivityResponse>(request, options));
}
public async Task <CreateEntityResponse> Create(CreateActivityRequest activity)
{
var newActivity = new Activity
{
Name = activity.Name,
Description = activity.Description,
DueDate = activity.DueDate,
ClientId = activity.ClientId
};
var result = await _activitiesRepo.Create(newActivity);
return(result);
}
public async Task <Response <string> > AddActivity(CreateActivityRequest request)
{
var activity = new Activity
{
ActivityName = request.ActivityName,
MediaFileUrl = request.MediaFileURL,
TypeId = request.TypeId,
SuitableAge = request.SuitableAge,
DelFlag = false,
};
await _unitOfWork.ActivityRepository.AddAsync(activity);
await _unitOfWork.SaveAsync();
return(new Response <string>(activity.Id.ToString(), $"Thêm activity thành công, id: {activity.Id}"));
}
public void Run()
{
var orders = FilterNotCreatedOrders();
FileLog.WriteLineIf("Enviando ordens para o Field Control");
FileLog.WriteJson(orders);
foreach (var order in orders)
{
try
{
var activity = _conveter.ConvertFrom(order);
FileLog.WriteJson(order);
FileLog.WriteJson(activity);
var request = new CreateActivityRequest(activity);
_fieldControlClient.Execute(request);
}
catch (RequestErrorException fex)
{
FileLog.WriteError("Field Control Api Error " + fex.Message);
FileLog.WriteError(fex.ResponseBody);
}
catch (ApplicationException aex)
{
FileLog.WriteError("Sync App Error " + aex.Message);
FileLog.WriteError(aex.StackTrace);
}
catch (Exception ex)
{
FileLog.WriteError("Generic Error " + ex.Message);
FileLog.WriteError(ex.StackTrace);
}
}
}
/// <summary>
/// Checks whether the create activity request is valid.
/// <para>This function does not verify the uniqueness of the activity identifier.
/// It also does not verify whether a closer proximity server exists.</para>
/// </summary>
/// <param name="CreateActivityRequest">Create activity request part of the client's request message.</param>
/// <param name="Client">Client that sent the request.</param>
/// <param name="RequestMessage">Full request message from client.</param>
/// <param name="ErrorResponse">If the function fails, this is filled with error response message that is ready to be sent to the client.</param>
/// <returns>true if the create activity request can be applied, false otherwise.</returns>
public static bool ValidateCreateActivityRequest(CreateActivityRequest CreateActivityRequest, IncomingClient Client, ProxProtocolMessage RequestMessage, out ProxProtocolMessage ErrorResponse)
{
log.Trace("()");
bool res = false;
ErrorResponse = null;
string details = null;
if (CreateActivityRequest == null)
{
CreateActivityRequest = new CreateActivityRequest();
}
if (CreateActivityRequest.Activity == null)
{
CreateActivityRequest.Activity = new ActivityInformation();
}
if (CreateActivityRequest.Activity.ProfileServerContact == null)
{
CreateActivityRequest.Activity.ProfileServerContact = new ServerContactInfo();
}
SignedActivityInformation signedActivity = new SignedActivityInformation()
{
Activity = CreateActivityRequest.Activity,
Signature = RequestMessage.Request.ConversationRequest.Signature
};
if (ValidateSignedActivityInformation(signedActivity, Client.PublicKey, Client.MessageBuilder, RequestMessage, "", false, out ErrorResponse))
{
byte[] ownerPubKey = CreateActivityRequest.Activity.OwnerPublicKey.ToByteArray();
if (!ByteArrayComparer.Equals(Client.PublicKey, ownerPubKey))
{
log.Debug("Client's public key '{0}' does not match activity owner's public key '{1}'.", Client.PublicKey.ToHex(), ownerPubKey.ToHex());
details = "activity.ownerPublicKey";
}
if (details == null)
{
int index = 0;
foreach (ByteString serverId in CreateActivityRequest.IgnoreServerIds)
{
if (serverId.Length != ProtocolHelper.NetworkIdentifierLength)
{
log.Debug("Ignored server ID #{0} is not a valid network ID as its length is {1} bytes.", index, serverId.Length);
details = "ignoreServerIds";
break;
}
index++;
}
}
if (details == null)
{
res = true;
}
else
{
ErrorResponse = Client.MessageBuilder.CreateErrorInvalidValueResponse(RequestMessage, details);
}
}
log.Trace("(-):{0}", res);
return(res);
}
public async Task <CreateEntityResponse> Create([FromBody] CreateActivityRequest activity)
{
var activityId = await _activityService.Create(activity);
return(activityId);
}
public async Task <IActionResult> AddActivity(CreateActivityRequest request)
{
return(Ok(await _activityService.AddActivity(request)));
}
public async Task CreateAsync(CreateActivityRequest request) => await _service.CreateAsync(request);
public async Task CreateAsync(CreateActivityRequest request) => await _writeRepository.CreateAsync(request);
public CreateActivityModel CreateActivityModel(CreateActivityRequest createActivityRequest)
{
var roundUp = DateTime.Now.RoundUp();
return new CreateActivityModel { StartAt = roundUp, EndAt = roundUp.AddHours(1) };
}
