public CreateResponse CreateAccount(CreateRequest request)
{
CreateResponse response = new CreateResponse();
try
{
// Create new account object
Account newAccount = new Account(request.Balance);
// Add our new object to pending for pesistence.
_accountRepository.Add(newAccount);
// Persist our changes to database.
_unitOfWork.Commit();
}
catch (Exception)
{
response.IsSuccessful = false;
response.Message = "Unable to create account! If problem persist, please contact system administrator.";
return response;
}
response.IsSuccessful = true;
response.Message = "Account created.";
return response;
}
public CreateResponse CreateExercise(Exercise exercise)
{
CreateResponse cr = new CreateResponse();
Common.Collections coll = new Collections();
cr = coll.CreateExercise(exercise);
return cr;
}
public CreateResponse CreateExercise(Models.Exercise exercise)
{
var resp = new CreateResponse();
//set datetime
exercise.date = DateTime.Now.ToString("s").Replace('T', ' ') + "UTC";
DataAccess.DataAccess da = new DataAccess.DataAccess();
da.CreateExerciseCollection(exercise);
return resp;
}
private void HandleCreateResponse(CreateResponse createResponse, EntityResultSet resultSet)
{
if (createResponse != null)
{
// if(orgCommand.Columns.Any)
// for execute reader and execute scalar purposes, we provide a result that has the newly created id of the entity.
var request = (CreateRequest)Request;
var entResult = new Entity(request.Target.LogicalName);
// Populate results for execute reader and execute scalar purposes.
var idattname = string.Format("{0}id", request.Target.LogicalName);
entResult[idattname] = createResponse.id;
entResult.Id = createResponse.id;
resultSet.Results = new EntityCollection(new List<Entity>(new Entity[] { entResult }));
// Add column metadata for the results we are returning, in this case it's just the id.
string[] resultattributes = new string[] { idattname };
// AddResultColumnMetadata(orgCommand, resultSet, request.Target.LogicalName, resultattributes);
}
}
internal static Response ByteToResponse(byte[] rawResponse)
{
String responseTostr = Encoding.UTF8.GetString(rawResponse);
return(CreateResponse.GetResponse(responseTostr));
}
/// <summary>
/// This method first connects to the Organization service. Afterwards,
/// basic create, retrieve, update, and delete entity operations are performed.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
try
{
//<snippetInvokeDuplicateDetectionForCreateAndUpdate1>
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri, serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// This statement is required to enable early-bound type support.
_serviceProxy.EnableProxyTypes();
_service = (IOrganizationService)_serviceProxy;
CreateRequiredRecords();
// Create and account record with the named Proseware, Inc. and already existing Account Number.
Account account = new Account
{
Name = "Proseware, Inc.",
AccountNumber = "ACC005"
};
// Create operation by suppressing duplicate detection
CreateRequest reqCreate = new CreateRequest();
reqCreate.Target = account;
reqCreate.Parameters.Add("SuppressDuplicateDetection", true); // Change to false to activate the duplicate detection.
CreateResponse createResponse = (CreateResponse)_service.Execute(reqCreate);
_dupAccountId = createResponse.id;
Console.Write("Account: {0} {1} created with SuppressDuplicateDetection to true, ",
account.Name, account.AccountNumber);
// Retrieve the account containing with its few attributes.
ColumnSet cols = new ColumnSet(
new String[] { "name", "accountnumber" });
Account retrievedAccount = (Account)_service.Retrieve("account", _dupAccountId, cols);
Console.Write("retrieved, ");
// Update the existing account with new account number.
retrievedAccount.AccountNumber = "ACC006";
// Update operation – update record, if a duplicate is not found.
UpdateRequest reqUpdate = new UpdateRequest();
reqUpdate.Target = retrievedAccount;
reqUpdate["SuppressDuplicateDetection"] = false; // Duplicate detection is activated.
// Update the account record.
UpdateResponse updateResponse = (UpdateResponse)_service.Execute(reqUpdate);
Console.WriteLine("and updated.");
DeleteRequiredRecords(promptforDelete);
}
//</snippetInvokeDuplicateDetectionForCreateAndUpdate1>
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> )
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
public static void Run(int recordsNumber)
{
CrmServiceClient crmSvc = new CrmServiceClient(ConfigurationManager.ConnectionStrings["MyCRMServer"].ConnectionString);
using (svcContext context = new svcContext(crmSvc))
{
List <new_car> cars = context.new_carSet.ToList <new_car>();
List <new_carclass> carClasses = context.new_carclassSet.ToList <new_carclass>();
List <Contact> contacts = context.ContactSet.ToList <Contact>();
try
{
var createRentsReq = new ExecuteMultipleRequest()
{
Requests = new OrganizationRequestCollection(),
Settings = new ExecuteMultipleSettings
{
ContinueOnError = false,
ReturnResponses = true
}
};
Random random = new Random();
for (int i = 0; i < recordsNumber; i++)
{
DateTime reservedPickup =
Helpers.GenerateDateInRange(
new DateTime(Constants.RentDuration.YearFrom, Constants.RentDuration.MonthFrom, Constants.RentDuration.DayFrom),
new DateTime(Constants.RentDuration.YearTo, Constants.RentDuration.MonthTo, Constants.RentDuration.DayTo),
random);
TimeSpan rentDuration = Helpers.GenerateRentDuraton(random);
DateTime reservedReturn = reservedPickup.Add(rentDuration);
new_carclass carClass = Helpers.GetCarClass(carClasses, random);
Guid classId = carClass.Id;
Guid carId = Helpers.GetCarIdByClassId(classId, cars, random);
Guid customerId = Helpers.GetCustomerId(contacts, random);
int pickupLocationValue = Helpers.GetLocationValue(random);
int returnLocationValue = Helpers.GetLocationValue(random);
Money price = Helpers.GetPriceForRent(rentDuration, carClass);
new_rent rent = new new_rent
{
new_ReservedPickup = reservedPickup,
new_ReservedHandover = reservedReturn,
new_Price = price,
new_CarClass = new EntityReference(new_carclass.EntityLogicalName, classId),
new_Car = new EntityReference(new_car.EntityLogicalName, carId),
new_Customer = new EntityReference(Contact.EntityLogicalName, customerId),
new_PickupLocation = new OptionSetValue(pickupLocationValue),
new_ReturnLocation = new OptionSetValue(returnLocationValue)
};
var createRequest = new CreateRequest()
{
Target = rent
};
createRentsReq.Requests.Add(createRequest);
}
var rentsResponse = (ExecuteMultipleResponse)crmSvc.Execute(createRentsReq);
//--------- CREATE LISTS WITH RENTS IDS-----
List <string> created = new List <string>();
int createdInd = (int)(recordsNumber * 0.05);
List <string> confirmed = new List <string>();
int confirmedInd = createdInd + (int)(recordsNumber * 0.05);
List <string> renting = new List <string>();
int rentingInd = confirmedInd + (int)(recordsNumber * 0.05);
List <string> returned = new List <string>();
int returnedInd = rentingInd + (int)(recordsNumber * 0.75);
List <string> canceled = new List <string>();
int canceledInd = returnedInd + (int)(recordsNumber * 0.1);
int recordsCounter = 0;
foreach (var r in rentsResponse.Responses)
{
if (r.Response != null)
{
Console.WriteLine("Success on creation record#: " + recordsCounter);
if (recordsCounter < createdInd)
{
created.Add(r.Response.Results["id"].ToString());
}
else if (recordsCounter < confirmedInd)
{
confirmed.Add(r.Response.Results["id"].ToString());
}
else if (recordsCounter < rentingInd)
{
renting.Add(r.Response.Results["id"].ToString());
}
else if (recordsCounter < returnedInd)
{
returned.Add(r.Response.Results["id"].ToString());
}
else if (recordsCounter < canceledInd)
{
canceled.Add(r.Response.Results["id"].ToString());
}
}
else if (r.Fault != null)
{
Console.WriteLine(r.Fault);
}
recordsCounter++;
}
//------ UPDATE RENTS WITH REPORTS ----
var multipleRequest = new ExecuteMultipleRequest()
{
Requests = new OrganizationRequestCollection(),
Settings = new ExecuteMultipleSettings
{
ContinueOnError = false,
ReturnResponses = true
}
};
//------ CONFIRMED ----
for (int i = 0; i < confirmed.Count; i++)
{
Guid rentId = Guid.Parse(confirmed[i]);
new_rent newRent = new new_rent
{
Id = Guid.Parse(confirmed[i]),
new_Paid = i < Math.Round(confirmed.Count * 0.9),
statuscode = new OptionSetValue(Constants.RentStatus.Confirmed)
};
UpdateRequest updateRentRequest = new UpdateRequest {
Target = newRent
};
multipleRequest.Requests.Add(updateRentRequest);
}
//------ RENTING ----
for (int i = 0; i < renting.Count; i++)
{
Guid rentId = Guid.Parse(renting[i]);
new_rent currentRent = (new_rent)crmSvc.Retrieve(new_rent.EntityLogicalName, rentId, new ColumnSet(true));
new_cartransferreport newReport = new new_cartransferreport
{
new_Type = Constants.ReportType.Pickup,
new_Date = currentRent.new_ReservedPickup,
new_Car = currentRent.new_Car,
};
CreateRequest createReportRequest = new CreateRequest {
Target = newReport
};
CreateResponse cresp = (CreateResponse)crmSvc.Execute(createReportRequest);
Guid reportId = cresp.id;
new_rent newRent = new new_rent
{
Id = rentId,
new_Paid = i < Math.Round(renting.Count * 0.999),
statuscode = new OptionSetValue(Constants.RentStatus.Renting),
new_PickupReport = new EntityReference(new_cartransferreport.EntityLogicalName, reportId)
};
UpdateRequest updateRentRequest = new UpdateRequest {
Target = newRent
};
multipleRequest.Requests.Add(updateRentRequest);
}
//------ RETURNED -----
for (int i = 0; i < returned.Count; i++)
{
Guid rentId = Guid.Parse(returned[i]);
new_rent currentRent = (new_rent)crmSvc.Retrieve(new_rent.EntityLogicalName, rentId, new ColumnSet(true));
new_cartransferreport newPickupReport = new new_cartransferreport
{
new_Type = Constants.ReportType.Pickup,
new_Date = currentRent.new_ReservedPickup,
new_Car = currentRent.new_Car,
};
bool hasDamage = i < Math.Round(returned.Count * 0.5);
new_cartransferreport newReturnReport = new new_cartransferreport
{
new_Type = Constants.ReportType.Return,
new_Damages = hasDamage,
new_DamageDescription = hasDamage ? "damage" : null,
new_Date = currentRent.new_ReservedHandover,
new_Car = currentRent.new_Car,
};
CreateRequest createPickupReportRequest = new CreateRequest {
Target = newPickupReport
};
CreateResponse crespPickup = (CreateResponse)crmSvc.Execute(createPickupReportRequest);
Guid pickupReportId = crespPickup.id;
CreateRequest createReturnReportRequest = new CreateRequest {
Target = newReturnReport
};
CreateResponse crespReturn = (CreateResponse)crmSvc.Execute(createReturnReportRequest);
Guid returnReportId = crespReturn.id;
new_rent updRent = new new_rent
{
Id = rentId,
new_Paid = i < Math.Round(returned.Count * 0.9998),
statecode = new_rentState.Inactive,
statuscode = new OptionSetValue(Constants.RentStatus.Returned),
new_PickupReport = new EntityReference(new_cartransferreport.EntityLogicalName, pickupReportId),
new_ReturnReport = new EntityReference(new_cartransferreport.EntityLogicalName, returnReportId),
};
UpdateRequest updateRentRequest = new UpdateRequest {
Target = updRent
};
multipleRequest.Requests.Add(updateRentRequest);
}
//------ CANCELED -----
foreach (var id in canceled)
{
Guid rentId = Guid.Parse(id);
new_rent newRent = new new_rent
{
Id = rentId,
statecode = new_rentState.Inactive,
statuscode = new OptionSetValue(Constants.RentStatus.Canceled),
};
UpdateRequest updateRentRequest = new UpdateRequest {
Target = newRent
};
multipleRequest.Requests.Add(updateRentRequest);
}
var multipleResponse = (ExecuteMultipleResponse)crmSvc.Execute(multipleRequest);
int updatedIndex = 0;
foreach (var r in multipleResponse.Responses)
{
if (r.Response != null)
{
Console.WriteLine("succes on update: " + updatedIndex);
}
else if (r.Fault != null)
{
Console.WriteLine(r.Fault);
}
updatedIndex++;
}
Console.WriteLine("Press ANY key to Continue");
//Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.ReadLine();
}
}
}
public void Should_return_an_http_response_message_with_expected_status()
{
var response = new CreateResponse();
AssertExpectedStatus(response);
}
internal override OrganizationResponse Execute(OrganizationRequest orgRequest, EntityReference userRef)
{
var request = MakeRequest <CreateRequest>(orgRequest);
var resp = new CreateResponse();
var settings = MockupExecutionContext.GetSettings(request);
var entity = request.Target;
if (entity.LogicalName == null)
{
throw new MockupException("Entity needs a logical name");
}
var entityMetadata = metadata.EntityMetadata.GetMetadata(entity.LogicalName);
var clonedEntity = entity.CloneEntity(entityMetadata, new ColumnSet(true));
var validAttributes = clonedEntity.Attributes.Where(x => x.Value != null);
clonedEntity.Attributes = new AttributeCollection();
clonedEntity.Attributes.AddRange(validAttributes);
if (userRef != null && userRef.Id != Guid.Empty)
{
if (!security.HasPermission(clonedEntity, AccessRights.CreateAccess, userRef))
{
throw new FaultException($"Trying to create entity '{entity.LogicalName}'" +
$", but the calling user with id '{userRef.Id}' does not have Create access for that entity (SecLib::AccessCheckEx2 failed)");
}
if (core.GetMockupSettings().AppendAndAppendToPrivilegeCheck.GetValueOrDefault(true))
{
var references = clonedEntity.Attributes
.Where(x => x.Value is EntityReference && x.Key != "ownerid")
.ToArray();
if (references.Any())
{
if (!security.HasPermission(clonedEntity, AccessRights.AppendAccess, userRef))
{
throw new FaultException($"Trying to create entity '{entity.LogicalName}' with references" +
$", but the calling user with id '{userRef.Id}' does not have Append access for that entity");
}
}
foreach (var attr in references)
{
var reference = attr.Value as EntityReference;
if (settings.ServiceRole == MockupServiceSettings.Role.UI && !security.HasPermission(reference, AccessRights.ReadAccess, userRef))
{
throw new FaultException($"Trying to create entity '{entity.LogicalName}'" +
$", but the calling user with id '{userRef.Id}' does not have read access for referenced entity '{reference.LogicalName}' on attribute '{attr.Key}'");
}
if (!security.HasPermission(reference, AccessRights.AppendToAccess, userRef))
{
throw new FaultException($"Trying to create entity '{entity.LogicalName}'" +
$", but the calling user with id '{userRef.Id}' does not have AppendTo access for referenced entity '{reference.LogicalName}' on attribute '{attr.Key}'");
}
}
}
}
if (Utility.HasCircularReference(metadata.EntityMetadata, clonedEntity))
{
throw new FaultException($"Trying to create entity '{clonedEntity.LogicalName}', but the attributes had a circular reference");
}
var transactioncurrencyId = "transactioncurrencyid";
var exchangerate = "exchangerate";
if (!clonedEntity.Attributes.ContainsKey(transactioncurrencyId) &&
Utility.IsValidAttribute(transactioncurrencyId, entityMetadata) &&
entityMetadata.Attributes.Any(m => m is MoneyAttributeMetadata) &&
(settings.ServiceRole == MockupServiceSettings.Role.UI ||
(settings.ServiceRole == MockupServiceSettings.Role.SDK && clonedEntity.Attributes.Any(
attr => entityMetadata.Attributes.Where(a => a is MoneyAttributeMetadata).Any(m => m.LogicalName == attr.Key)))))
{
var user = db.GetEntityOrNull(userRef);
if (user.Attributes.ContainsKey(transactioncurrencyId))
{
clonedEntity.Attributes[transactioncurrencyId] = user[transactioncurrencyId];
}
else
{
clonedEntity.Attributes[transactioncurrencyId] = Utility.GetBaseCurrency(metadata);
}
}
if (!clonedEntity.Attributes.ContainsKey(exchangerate) &&
Utility.IsValidAttribute(exchangerate, entityMetadata) &&
clonedEntity.Attributes.ContainsKey(transactioncurrencyId))
{
var currencyId = clonedEntity.GetAttributeValue <EntityReference>(transactioncurrencyId);
var currency = db.GetEntityOrNull(currencyId);
clonedEntity.Attributes[exchangerate] = currency["exchangerate"];
Utility.HandleCurrencies(metadata, db, clonedEntity);
}
if (Utility.IsValidAttribute("statecode", entityMetadata) &&
Utility.IsValidAttribute("statuscode", entityMetadata))
{
var defaultState = 0;
try
{
var defaultStateStatus = metadata.DefaultStateStatus[clonedEntity.LogicalName];
if (!clonedEntity.Attributes.ContainsKey("statecode") &&
!clonedEntity.Attributes.ContainsKey("statuscode"))
{
clonedEntity["statecode"] = new OptionSetValue(defaultState);
clonedEntity["statuscode"] = new OptionSetValue(defaultStateStatus[defaultState]);
}
else
{
var statusmeta =
(entityMetadata.Attributes.FirstOrDefault(a => a.LogicalName == "statuscode") as StatusAttributeMetadata)
?.OptionSet.Options
.Cast <StatusOptionMetadata>()
.FirstOrDefault(o => o.Value == clonedEntity.GetAttributeValue <OptionSetValue>("statuscode")?.Value);
if (clonedEntity.LogicalName != "opportunityclose" && // is allowed to be created inactive
((clonedEntity.Attributes.ContainsKey("statecode") &&
clonedEntity.GetAttributeValue <OptionSetValue>("statecode")?.Value != defaultState) ||
(clonedEntity.Attributes.ContainsKey("statuscode") && statusmeta?.State != defaultState)))
{
clonedEntity["statecode"] = new OptionSetValue(defaultState);
clonedEntity["statuscode"] = new OptionSetValue(defaultStateStatus[defaultState]);
}
else if (!clonedEntity.Contains("statecode") || clonedEntity.GetAttributeValue <OptionSetValue>("statecode") == null)
{
clonedEntity["statecode"] = new OptionSetValue(statusmeta.State.Value);
}
else if (!clonedEntity.Contains("statuscode") || clonedEntity.GetAttributeValue <OptionSetValue>("statuscode") == null)
{
clonedEntity["statuscode"] = new OptionSetValue(defaultStateStatus[defaultState]);
}
}
}
catch (KeyNotFoundException)
{
throw new KeyNotFoundException($"Unable to get default status reason for the state {defaultState.ToString()} in {clonedEntity.LogicalName} entity. " +
$"This might be due to unsaved default status reason changes. Please update, save, and publish the relevant status reason field on {clonedEntity.LogicalName} and generate new metadata");
}
}
if (Utility.IsValidAttribute("createdon", entityMetadata))
{
clonedEntity["createdon"] = DateTime.UtcNow.Add(core.TimeOffset);
}
if (Utility.IsValidAttribute("createdby", entityMetadata))
{
clonedEntity["createdby"] = userRef;
}
if (Utility.IsValidAttribute("modifiedon", entityMetadata) &&
Utility.IsValidAttribute("modifiedby", entityMetadata))
{
clonedEntity["modifiedon"] = clonedEntity["createdon"];
clonedEntity["modifiedby"] = clonedEntity["createdby"];
}
var owner = userRef;
if (clonedEntity.Attributes.ContainsKey("ownerid"))
{
owner = clonedEntity.GetAttributeValue <EntityReference>("ownerid");
}
Utility.SetOwner(db, security, metadata, clonedEntity, owner);
if (!clonedEntity.Attributes.ContainsKey("businessunitid") &&
(clonedEntity.LogicalName == LogicalNames.SystemUser || clonedEntity.LogicalName == LogicalNames.Team))
{
clonedEntity["businessunitid"] = metadata.RootBusinessUnit.ToEntityReference();
}
if (clonedEntity.LogicalName == LogicalNames.BusinessUnit)
{
CheckBusinessUnitAttributes(clonedEntity, settings);
}
foreach (var attr in entityMetadata.Attributes.Where(a => (a as BooleanAttributeMetadata)?.DefaultValue != null).ToList())
{
if (!clonedEntity.Attributes.Any(a => a.Key == attr.LogicalName))
{
clonedEntity[attr.LogicalName] = (attr as BooleanAttributeMetadata).DefaultValue;
}
}
foreach (var attr in entityMetadata.Attributes.Where(a =>
(a as PicklistAttributeMetadata)?.DefaultFormValue != null && (a as PicklistAttributeMetadata)?.DefaultFormValue.Value != -1).ToList())
{
if (!clonedEntity.Attributes.Any(a => a.Key == attr.LogicalName))
{
clonedEntity[attr.LogicalName] = new OptionSetValue((attr as PicklistAttributeMetadata).DefaultFormValue.Value);
}
}
if (clonedEntity.LogicalName == LogicalNames.Contact || clonedEntity.LogicalName == LogicalNames.Lead || clonedEntity.LogicalName == LogicalNames.SystemUser)
{
Utility.SetFullName(metadata, clonedEntity);
}
clonedEntity.Attributes
.Where(x => x.Value is string && x.Value != null && string.IsNullOrEmpty((string)x.Value))
.ToList()
.ForEach(x => clonedEntity[x.Key] = null);
if (Utility.Activities.Contains(clonedEntity.LogicalName))
{
clonedEntity["activitytypecode"] = Utility.ActivityTypeCode[clonedEntity.LogicalName];
var req = new CreateRequest
{
Target = clonedEntity.ToActivityPointer()
};
core.Execute(req, userRef);
}
db.Add(clonedEntity);
if (clonedEntity.LogicalName == LogicalNames.BusinessUnit)
{
security.AddRolesForBusinessUnit(db, clonedEntity.ToEntityReference());
CreateDefaultTeamForBusinessUnit(clonedEntity, userRef);
}
if (entity.RelatedEntities.Count > 0)
{
foreach (var relatedEntities in entity.RelatedEntities)
{
if (Utility.GetRelationshipMetadataDefaultNull(metadata.EntityMetadata, relatedEntities.Key.SchemaName, Guid.Empty, userRef) == null)
{
throw new FaultException($"Relationship with schemaname '{relatedEntities.Key.SchemaName}' does not exist in metadata");
}
foreach (var relatedEntity in relatedEntities.Value.Entities)
{
var req = new CreateRequest()
{
Target = relatedEntity
};
core.Execute(req, userRef);
}
var associateReq = new AssociateRequest
{
Target = entity.ToEntityReference(),
Relationship = relatedEntities.Key,
RelatedEntities = new EntityReferenceCollection(relatedEntities.Value.Entities.Select(e => e.ToEntityReference()).ToList())
};
core.Execute(associateReq, userRef);
}
}
resp.Results.Add("id", clonedEntity.Id);
return(resp);
}
public void Should_Be_Able_To_Execute_An_Insert_Using_ExecuteReader_And_Get_Back_Inserted_Id()
{
// Arrange
using (var sandbox = ConnectionTestsSandbox.Create())
{
var dbConnection = sandbox.Container.Resolve <CrmDbConnection>();
var insertCommand = new CrmDbCommand(dbConnection);
insertCommand.CommandText = "INSERT INTO contact (firstname, lastname) VALUES ('JO','SCHMO')";
insertCommand.CommandType = System.Data.CommandType.Text;
var provider = new SqlGenerationCrmOperationProvider(new DynamicsAttributeTypeProvider());
var orgCommand = provider.GetOperation(insertCommand, System.Data.CommandBehavior.Default);
// This is the fake reponse that the org service will return when its requested to get the data.
Guid expectedId = Guid.NewGuid();
var response = new CreateResponse
{
Results = new ParameterCollection
{
{ "id", expectedId }
}
};
// Results = new ParameterCollection
//{
//{ "EntityCollection", new EntityCollection(fakeContactsData){EntityName = "contact"} }
//}
// Setup fake org service to return fake response.
sandbox.FakeOrgService.Stub(f => f.Execute(Arg <OrganizationRequest> .Matches(new OrganizationRequestMessageConstraint <CreateRequest>())))
.WhenCalled(x =>
{
var request = ((CreateRequest)x.Arguments[0]);
}).Return(response);
// Act
var sut = CrmOperationExecutor.Instance;
dbConnection.Open();
var commandResult = sut.ExecuteOperation(orgCommand);
var results = commandResult.ResultSet;
// var results = sut.ExecuteCommand(orgCommand, System.Data.CommandBehavior.Default);
// results should contain record
Assert.That(results.ResultCount() == 1);
Assert.That(results.HasColumnMetadata());
var reader = commandResult.GetReader();
Assert.That(reader.HasRows);
Assert.That(reader.FieldCount == 1);
while (reader.Read())
{
Assert.That(reader.GetGuid(0), NUnit.Framework.Is.EqualTo(expectedId));
}
}
}
public void Should_Be_Able_To_Insert_And_Retrieve_Inserted_Account_In_Single_Bulk_Request()
{
var connectionString = ConfigurationManager.ConnectionStrings["CrmOrganisation"];
using (var conn = new CrmDbConnection(connectionString.ConnectionString))
{
conn.Open();
var orgService = conn.OrganizationService;
// Create an ExecuteMultipleRequest object.
var multipleRequests = new ExecuteMultipleRequest()
{
// Assign settings that define execution behavior: continue on error, return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = true
},
// Create an empty organization request collection.
Requests = new OrganizationRequestCollection()
};
var entity = new Entity("account");
entity.Id = Guid.NewGuid();
entity["name"] = "experimental test";
CreateRequest createRequest = new CreateRequest
{
Target = entity
};
RetrieveRequest retrieveRequest = new RetrieveRequest
{
Target = new EntityReference(entity.LogicalName, entity.Id),
ColumnSet = new ColumnSet("createdon")
};
multipleRequests.Requests.Add(createRequest);
multipleRequests.Requests.Add(retrieveRequest);
// Execute all the requests in the request collection using a single web method call.
ExecuteMultipleResponse responseWithResults = (ExecuteMultipleResponse)orgService.Execute(multipleRequests);
var createResponseItem = responseWithResults.Responses[0];
CreateResponse createResponse = null;
if (createResponseItem.Response != null)
{
createResponse = (CreateResponse)createResponseItem.Response;
}
var retrieveResponseItem = responseWithResults.Responses[1];
RetrieveResponse retrieveResponse = null;
if (retrieveResponseItem.Response != null)
{
retrieveResponse = (RetrieveResponse)retrieveResponseItem.Response;
}
Console.Write(retrieveResponse.Entity["createdon"]);
}
}
public void Should_Be_Able_To_Update_DataSet_Containing_An_Insert_An_Update_And_A_Delete_Using_Command_Builder()
{
// Arrange
using (var sandbox = ConnectionTestsSandbox.Create())
{
var dbConnection = sandbox.Container.Resolve <CrmDbConnection>();
var selectCommand = new CrmDbCommand(dbConnection);
selectCommand.CommandText = "SELECT contactid, firstname, lastname FROM contact";
// Create a dataset, fill with schema.
var ds = new DataSet();
var subject = ResolveTestSubjectInstance();
subject.SelectCommand = selectCommand;
// Use command builder to generate automatically the update / delete / insert commands.
using (var commandBuilder = new CrmCommandBuilder(subject))
{
var result = subject.FillSchema(ds, SchemaType.Source);
// Fill the dataset with 100 contact entities from the data source.
int resultCount = 100;
var entityDataGenerator = new EntityDataGenerator();
IList <Entity> fakeContactsData = entityDataGenerator.GenerateFakeEntities("contact", resultCount);
// This is the fake reponse that the org service will return when its requested to get the data.
var retrieveResponse = new RetrieveMultipleResponse
{
Results = new ParameterCollection
{
{ "EntityCollection", new EntityCollection(fakeContactsData)
{
EntityName = "contact"
} }
}
};
// Setup fake org service to return fake response.
sandbox.FakeOrgService.Stub(f => f.Execute(Arg <OrganizationRequest> .Matches(new OrganizationRequestMessageConstraint <RetrieveMultipleRequest>())))
.WhenCalled(x =>
{
var request = ((RetrieveMultipleRequest)x.Arguments[0]);
}).Return(retrieveResponse);
subject.Fill(ds);
// Now add a new contact, update an existing contact, and delete an existing contact.
var newContact = entityDataGenerator.GenerateFakeEntities("contact", 1)[0];
var contactDataTable = ds.Tables[0];
var firstNameCol = contactDataTable.Columns["firstname"];
var lastnameCol = contactDataTable.Columns["lastname"];
var contactidcol = contactDataTable.Columns["contactid"];
var newRow = contactDataTable.NewRow();
newRow.SetField(firstNameCol, newContact["firstname"]);
newRow.SetField(lastnameCol, newContact["lastname"]);
newRow.SetField(contactidcol, newContact.Id);
contactDataTable.Rows.Add(newRow);
// update existing contact.
var modifiedRow = contactDataTable.Rows[50];
var updatedFirstName = "Jessie";
var updatedLastName = "James";
modifiedRow.SetField(firstNameCol, updatedFirstName);
modifiedRow.SetField(lastnameCol, updatedLastName);
// Delete existing contact
var deleteRow = contactDataTable.Rows[99];
var deleteContactId = (Guid)deleteRow[contactidcol];
deleteRow.Delete();
// When we call update on the dataset we need to verify that the org service is sent
// an appropriate Create / Updated and Delete Request.
var createResponse = new CreateResponse
{
Results = new ParameterCollection
{
{ "id", newContact.Id }
}
};
// Setup fake org service create response.
CreateRequest capturedCreateRequest = null;
sandbox.FakeOrgService.Stub(f => f.Execute(Arg <OrganizationRequest> .Matches(new OrganizationRequestMessageConstraint <CreateRequest>())))
.WhenCalled(x =>
{
var request = ((CreateRequest)x.Arguments[0]);
capturedCreateRequest = request;
}).Return(createResponse);
// Setup fake org service update response.
var updateResponse = new UpdateResponse
{
Results = new ParameterCollection()
{
}
};
UpdateRequest capturedUpdateRequest = null;
sandbox.FakeOrgService.Stub(f => f.Execute(Arg <OrganizationRequest> .Matches(new OrganizationRequestMessageConstraint <UpdateRequest>())))
.WhenCalled(x =>
{
var request = ((UpdateRequest)x.Arguments[0]);
capturedUpdateRequest = request;
}).Return(updateResponse);
// Setup fake org service delete response.
var deleteResponse = new DeleteResponse
{
Results = new ParameterCollection()
{
}
};
DeleteRequest capturedDeleteRequest = null;
sandbox.FakeOrgService.Stub(f => f.Execute(Arg <OrganizationRequest> .Matches(new OrganizationRequestMessageConstraint <DeleteRequest>())))
.WhenCalled(x =>
{
var request = ((DeleteRequest)x.Arguments[0]);
capturedDeleteRequest = request;
}).Return(deleteResponse);
var updateCommand = commandBuilder.GetUpdateCommand();
Console.WriteLine(updateCommand.CommandText);
// ACT
subject.Update(ds);
// ASSERT
// A create request for the new row data should have been captured.
// An update request for the modified row data should have been captured.
// A delete request for the deleted row should have been captured.
Assert.NotNull(capturedCreateRequest);
Assert.NotNull(capturedUpdateRequest);
Assert.NotNull(capturedDeleteRequest);
var forCreate = capturedCreateRequest.Target;
Assert.AreEqual(forCreate.Id, newContact.Id);
Assert.AreEqual(forCreate["firstname"], newContact["firstname"]);
Assert.AreEqual(forCreate["lastname"], newContact["lastname"]);
var forUpdate = capturedUpdateRequest.Target;
Assert.AreEqual(forUpdate.Id, modifiedRow[contactidcol]);
Assert.AreEqual(forUpdate["firstname"], updatedFirstName);
Assert.AreEqual(forUpdate["lastname"], updatedLastName);
var forDelete = capturedDeleteRequest.Target;
Assert.AreEqual(forDelete.Id, deleteContactId);
}
}
}
/// <summary>
/// Service Initialization
/// Connect to the Brick and then open up the service for all requests
/// </summary>
/// <returns></returns>
public virtual IEnumerator<ITask> ServiceInitialization(CreateResponse createResponse)
{
// Set up the _brickPort to our communications service
_brickPort = ServiceForwarder<comm.LegoCommOperations>(createResponse.Service);
// Subscribe to the communications port.
yield return Arbiter.Choice(_brickPort.Subscribe(_brickNotificationPort),
EmptyHandler<SubscribeResponseType>,
EmptyHandler<Fault>);
// If the SerialPort is not set, start the service,
// but do not attempt to connect to the actual hardware.
bool done = (_state.Configuration.SerialPort == 0);
if (!done)
{
// If we are not done yet, attempt to connect to the hardware.
NxtBrickOperations _initPort = new NxtBrickOperations();
PortSet<DefaultUpdateResponseType, Fault> _initResponse = new PortSet<DefaultUpdateResponseType, Fault>();
ConnectToHardware connectToHardware = new ConnectToHardware(_state.Configuration, _initResponse);
_initPort.Post(connectToHardware);
// Special one time handler to connect to the hardware before we open up the service to receive messages.
Activate<ITask>(
Arbiter.ReceiveWithIterator<ConnectToHardware>(false, _initPort, ConnectToHardwareHandler),
new Interleave(
new TeardownReceiverGroup(
Arbiter.ReceiveWithIterator<DefaultUpdateResponseType>(false, _initResponse, InitializationComplete),
Arbiter.ReceiveWithIterator<Fault>(false, _initResponse, InitializationComplete),
Arbiter.ReceiveWithIterator<DsspDefaultDrop>(false, _internalMainPort, DropHandler)
),
new ExclusiveReceiverGroup(
Arbiter.ReceiveWithIterator<AttachAndSubscribe>(true, _internalMainPort, AttachAndSubscribeHandler),
Arbiter.ReceiveWithIterator<ReserveDevicePort>(true, _internalMainPort, ReserveDevicePortHandler),
Arbiter.ReceiveWithIterator<Subscribe>(true, _internalMainPort, SubscribeHandler),
Arbiter.ReceiveWithIterator<Detach>(true, _internalMainPort, DetachHandler),
Arbiter.ReceiveWithIterator<AdjustPollingFrequency>(true, _internalMainPort, AdjustPollingFrequencyHandler)
),
new ConcurrentReceiverGroup())
);
}
else
{
SpawnIterator<DefaultUpdateResponseType>(DefaultUpdateResponseType.Instance, InitializationComplete);
}
yield break;
}
private static async Task RunTest()
{
AuthInfo authInfo = GetAuthInfo();
AuthenticationClient auth = new AuthenticationClient(authInfo.ApiVersion);
try
{
await auth.UsernamePasswordAsync(authInfo.ClientId, authInfo.ClientSecret, authInfo.Username, authInfo.Password, authInfo.TokenRequestEndpoint);
Console.WriteLine("Successfully connected to Salesforce");
}
catch (ForceAuthException ex)
{
Console.WriteLine("ForceAuthException: " + ex.Message);
return;
}
catch (Exception ex)
{
Console.WriteLine("General Exception at login: "******"SELECT Id, Name, SystemModstamp, Account.Id, Account.Name, Account.SystemModstamp FROM Contact", false);
List <CustomAccount> customAccounts = await client.Query <CustomAccount>("SELECT Id, CustomerPriority__c FROM Account", false);
//Using a dynamic object
dynamic dynoObject = new ExpandoObject();
dynoObject.Name = "Test Account";
dynoObject.Description = "Test Account description";
CreateResponse resp = await client.CreateRecord <dynamic>("Account", dynoObject);
// Asynchronous large result sets and batching:
// Query<T> method will retrieve the full result set before returning.
// In cases where you are working with large result sets, you may want to retrieve the batches asynchronously for better performance.
// First create the async enumerable. At this point, no query has been executed.
// batchSize can be omitted to use the default (usually 2000), or given a custom value between 200 and 2000.
IAsyncEnumerable <SfContact> contactsEnumerable = client.QueryAsync <SfContact>("SELECT Id, Name FROM Contact ", batchSize: 200);
// Get the enumerator, in a using block for proper disposal
await using (IAsyncEnumerator <SfContact> contactsEnumerator = contactsEnumerable.GetAsyncEnumerator())
{
// MoveNext() will execute the query and get the first batch of results.
// Once the inital result batch has been exhausted, the remaining batches, if any, will be retrieved.
while (await contactsEnumerator.MoveNextAsync())
{
SfContact contact = contactsEnumerator.Current;
// process your results
}
}
}
catch (ForceApiException ex)
{
Console.WriteLine("ForceApiException: " + ex.Message);
return;
}
catch (Exception ex)
{
Console.WriteLine("General Exception: " + ex.Message);
return;
}
return;
}
public static CreateResponse CreateWebResource(IOrganizationService orgService, string solutionUniqueName, string displayName, string schemaName, string prefix, string instrumentationKey)
{
const string AI_INIT_JS = "AI.Init.js";
// Check if AI.Init.js already exists
Guid aiWebResourceId = Guid.Empty;
QueryExpression qeAiWr = new QueryExpression("webresource");
qeAiWr.Criteria.AddCondition("name", ConditionOperator.Equal, string.Format("{0}{1}", prefix, AI_INIT_JS));
EntityCollection ecAiWr = orgService.RetrieveMultiple(qeAiWr);
if (ecAiWr != null && ecAiWr.Entities != null && ecAiWr.Entities.Count > 0)
{
aiWebResourceId = ecAiWr.Entities[0].Id;
}
// Create only if AI.Init.js does not exists
if (aiWebResourceId == Guid.Empty)
{
// Create AI.Init.js file
Entity aiWebResource = new Entity("webresource");
aiWebResource.Attributes.Add("name", string.Format("{0}{1}", prefix, AI_INIT_JS));
aiWebResource.Attributes.Add("displayname", AI_INIT_JS);
aiWebResource.Attributes.Add("content", FileHelper.GetAiInitFileContents(instrumentationKey));
aiWebResource.Attributes.Add("description", "Azure Application Insights initializer script.");
aiWebResource.Attributes.Add("webresourcetype", new OptionSetValue(3));// 3 = JScript
// Using CreateRequest because we want to add an optional parameter
CreateRequest aiRequest = new CreateRequest
{
Target = aiWebResource
};
// Set the SolutionUniqueName optional parameter so the Web Resources will be created in the context of a specific solution.
aiRequest.Parameters.Add("SolutionUniqueName", solutionUniqueName);
CreateResponse aiResponse = (CreateResponse)orgService.Execute(aiRequest);
aiWebResourceId = aiResponse.id;
}
// Create D365Insights.js file
var d365InsightsDependencyXml = @"<Dependencies><Dependency componentType=""WebResource""><Library name=""" + string.Format("{0}{1}", prefix, AI_INIT_JS) + @""" displayName=""" + AI_INIT_JS + @""" languagecode="""" description=""Azure Application Insights initializer script."" libraryUniqueId=""{" + aiWebResourceId + @"}""/></Dependency></Dependencies>";
Entity d365InsightsWebResource = new Entity("webresource");
d365InsightsWebResource.Attributes.Add("name", string.Format("{0}{1}", prefix, schemaName));
d365InsightsWebResource.Attributes.Add("displayname", displayName);
d365InsightsWebResource.Attributes.Add("content", FileHelper.GetD365InsightsFileContents(instrumentationKey));
d365InsightsWebResource.Attributes.Add("description", "Javascript to trace the client insights in Azure Application Insights.");
d365InsightsWebResource.Attributes.Add("webresourcetype", new OptionSetValue(3));// 3 = JScript
d365InsightsWebResource.Attributes.Add("dependencyxml", d365InsightsDependencyXml);
// Using CreateRequest because we want to add an optional parameter
CreateRequest d365InsightsRequest = new CreateRequest
{
Target = d365InsightsWebResource
};
// Set the SolutionUniqueName optional parameter so the Web Resources will be created in the context of a specific solution.
d365InsightsRequest.Parameters.Add("SolutionUniqueName", solutionUniqueName);
CreateResponse d365InsightsResponse = (CreateResponse)orgService.Execute(d365InsightsRequest);
return(d365InsightsResponse);
}
public CreateResponse <ProjectUserRequestDTO> Create(Guid id, CreateProjectUserReqRequest req)
{
var res = new CreateResponse <ProjectUserRequestDTO>();
var role = _roleRepository.FindById(req.RoleId);
if (role == null)
{
return((CreateResponse <ProjectUserRequestDTO>)
res.ReturnErrorResponseWith("Role not found."));
}
var project = _projectRepository.FindById(req.ProjectId);
if (project == null)
{
return((CreateResponse <ProjectUserRequestDTO>)
res.ReturnErrorResponseWith("Project not found."));
}
var sender = _userRepository.FindById(id);
if (sender == null)
{
return((CreateResponse <ProjectUserRequestDTO>)
res.ReturnErrorResponseWith("Invalid sender."));
}
var userAssigned = _userRepository.FindById(req.UserAssignedId);
if (userAssigned == null)
{
return((CreateResponse <ProjectUserRequestDTO>)
res.ReturnErrorResponseWith("Assigned user not found."));
}
var projectManagers = project.ProjectUsersReq
.Where(pur => pur.Accepted == true && pur.Role.RoleName == "PROJECT_MANAGER").ToList();
if (projectManagers.Find(pur => pur.UserAssigned.Id == id) == null)
{
return((CreateResponse <ProjectUserRequestDTO>)
res.ReturnErrorResponseWith("User must be project manager to send requests."));
}
if (project.ProjectUsersReq.ToList().Find(pur => pur.UserAssigned.Id == req.UserAssignedId) != null)
{
return((CreateResponse <ProjectUserRequestDTO>)
res.ReturnErrorResponseWith("User has alredy received an invitation."));
}
var projectUserReq = new ProjectUserReq()
{
Id = Guid.NewGuid(),
Message = req.Message,
UserAssigned = userAssigned,
Sender = sender,
Role = role,
Project = project,
Accepted = false,
RequestSent = DateTime.Now
};
projectUserReq.Validate();
if (projectUserReq.GetBrokenRules().Count > 0)
{
return((CreateResponse <ProjectUserRequestDTO>)
res.ReturnErrorResponseWithMultiple(projectUserReq.GetBrokenRules()));
}
_projectUserReqRepository.Save(projectUserReq);
try
{
_uow.Commit();
}
catch (Exception ex)
{
return((CreateResponse <ProjectUserRequestDTO>)
res.ReturnErrorResponseWith(ex.Message));
}
res.Success = true;
return(res);
}
[STAThread] // Added to support UX
static void Main(string[] args)
{
CrmServiceClient service = null;
try
{
service = SampleHelpers.Connect("Connect");
if (service.IsReady)
{
#region Sample Code
//////////////////////////////////////////////
#region Set up
SetUpSample(service);
#endregion Set up
#region Demonstrate
//Read the descriptive data from the XML file
XDocument xmlDoc = XDocument.Load("../../ImportJob.xml");
//Create a collection of anonymous type references to each of the Web Resources
var webResources = from webResource in xmlDoc.Descendants("webResource")
select new
{
path = webResource.Element("path").Value,
displayName = webResource.Element("displayName").Value,
description = webResource.Element("description").Value,
name = webResource.Element("name").Value,
type = webResource.Element("type").Value
};
// Loop through the collection creating Web Resources
int counter = 0;
foreach (var webResource in webResources)
{
//<snippetImportWebResources2>
//Set the Web Resource properties
WebResource wr = new WebResource
{
Content = getEncodedFileContents(@"../../" + webResource.path),
DisplayName = webResource.displayName,
Description = webResource.description,
Name = _customizationPrefix + webResource.name,
LogicalName = WebResource.EntityLogicalName,
WebResourceType = new OptionSetValue(Int32.Parse(webResource.type))
};
// Using CreateRequest because we want to add an optional parameter
var cr = new CreateRequest
{
Target = wr
};
//Set the SolutionUniqueName optional parameter so the Web Resources will be
// created in the context of a specific solution.
cr.Parameters.Add("SolutionUniqueName", _ImportWebResourcesSolutionUniqueName);
CreateResponse cresp = (CreateResponse)service.Execute(cr);
//</snippetImportWebResources2>
// Capture the id values for the Web Resources so the sample can delete them.
_webResourceIds[counter] = cresp.id;
counter++;
Console.WriteLine("Created Web Resource: {0}", webResource.displayName);
}
#region Clean up
CleanUpSample(service);
#endregion Clean up
}
#endregion Demonstrate
else
{
const string UNABLE_TO_LOGIN_ERROR = "Unable to Login to Microsoft Dataverse";
if (service.LastCrmError.Equals(UNABLE_TO_LOGIN_ERROR))
{
Console.WriteLine("Check the connection string values in cds/App.config.");
throw new Exception(service.LastCrmError);
}
else
{
throw service.LastCrmException;
}
}
}
#endregion Sample Code
catch (Exception ex)
{
SampleHelpers.HandleException(ex);
}
finally
{
if (service != null)
{
service.Dispose();
}
Console.WriteLine("Press <Enter> to exit.");
Console.ReadLine();
}
}
public JsonResult CreateMemo(HomeViewModel mod, string fileBase64)
{
XmlConfigurator.Configure();
string bts; byte[] file;
string fileType;
if (fileBase64 == null || fileBase64 == "")
{
bts = null;
fileType = null;
}
else
{
if (fileBase64.Contains("application/msword"))
{
bts = fileBase64.Remove(0, 31); fileType = fileBase64.Substring(0, 31);
}
else if (fileBase64.Contains("application/vnd"))
{
bts = fileBase64.Remove(0, 84); fileType = fileBase64.Substring(0, 84);
}
else
{
bts = fileBase64.Remove(0, 28); fileType = fileBase64.Substring(0, 28);
}
file = System.Convert.FromBase64String(bts);
}
CreateMemoModel mem = new CreateMemoModel();
CreateResponse resp = new CreateResponse();
mem.IRNumber = mod.IRNo;
mem.TransactionType = mod.DebitCredit;
mem.TransactionDate1 = mod.TransactionDate1;
mem.TransactionDate2 = mod.TransactionDate2;
mem.TransactionDate2 = mod.TransactionDate2;
mem.Reason1 = (mod.WrongAmount).Equals(true) ? "WrongAmount" : null;
mem.Reason2 = (mod.Erroneous).Equals(true) ? "Erroneous" : null;
mem.Reason3 = (mod.SystemError).Equals(true) ? "SystemError" : null;
mem.ReferenceNo1 = !String.IsNullOrEmpty(mod.refno1) ? mod.refno1 : null;
mem.ReferenceNo2 = !String.IsNullOrEmpty(mod.refno2) ? mod.refno2 : null;
mem.ReferenceNo3 = !String.IsNullOrEmpty(mod.refno3) ? mod.refno3 : null;
mem.WalletUser = mod.WalletUser;
mem.WalletID = mod.WalletID;
mem.WrongAmount = mod.IncorrectAmount;
mem.CorrectAmount = mod.CorrectAmount;
mem.AdjustedAmount = mod.AdjustAmount;
mem.OperatorName = Session["user"].ToString();
mem.File = bts;
mem.FileType = fileType;
resp.data = mem;
byte[] data = UTF8Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(resp));
var source = new System.Uri(service + "/CreateMemo");
var reqHandler = new RequestHandler("POST", source, "application/json", data);
var response = reqHandler.HttpPostRequest();
if (!response.Contains("200"))
{
log.Info(response.ToString());
return(Json(new { status = "5000", msg = "System encountered an error. Please retry or contact admin." }));
}
else
{
resp = Newtonsoft.Json.JsonConvert.DeserializeObject <CreateResponse>(response);
log.Info(JsonConvert.SerializeObject(resp, Formatting.None).ToString());
return(Json(new { status = resp.ResponseCode, msg = resp.ResponsMessage }));
}
}
public CreateResponse <TicketDTO> Create(Guid id, CreateTicketRequest req)
{
var res = new CreateResponse <TicketDTO>();
var project = _projectRepository.FindById(req.ProjectId);
if (project == null)
{
return((CreateResponse <TicketDTO>)
res.ReturnErrorResponseWith("Specified project doesn't exist"));
}
var user = _userRepository.FindById(id);
if (user == null)
{
return((CreateResponse <TicketDTO>)
res.ReturnErrorResponseWith("Specified user doesn't exist"));
}
var projectUser = _projectUserReqRepository
.FindProjectUserFor(user.Id, project.Id);
if (projectUser == null)
{
return((CreateResponse <TicketDTO>)
res.ReturnErrorResponseWith("Only users on projects can make new tickets"));
}
var ticketStatus = _ticketStatusRepository.FindById(req.StatusId);
if (ticketStatus == null)
{
return((CreateResponse <TicketDTO>)
res.ReturnErrorResponseWith("Specified ticket status doesn't exist"));
}
var ticketType = req.TicketType == null ?
TicketType.UNDEFINED :
req.TicketType.ConvertToTicketType();
var ticket = _mapper.Map <CreateTicketRequest, Ticket>(req);
ticket.Reporter = projectUser;
ticket.Project = project;
ticket.Status = ticketStatus;
ticket.Created = DateTime.Now;
ticket.Type = ticketType;
Console.WriteLine(ticket);
ticket.Validate();
if (ticket.GetBrokenRules().Count > 0)
{
return((CreateResponse <TicketDTO>)
res.ReturnErrorResponseWithMultiple(ticket.GetBrokenRules()));
}
_ticketRepository.Save(ticket);
try
{
_uow.Commit();
}
catch (Exception ex)
{
return((CreateResponse <TicketDTO>)
res.ReturnErrorResponseWith(ex.Message));
}
res.Success = true;
res.EntityDTO = _mapper.Map <Ticket, TicketDTO>(ticket);
return(res);
}
public virtual async void TestBulkInsert()
{
var builder = new WebHostBuilder()
.UseEnvironment("Production")
.UseStartup <TestStartup>();
TestServer testServer = new TestServer(builder);
var client = new ApiClient(testServer.CreateClient());
client.SetBearerToken(JWTTestHelper.GenerateBearerToken());
ApplicationDbContext context = testServer.Host.Services.GetService(typeof(ApplicationDbContext)) as ApplicationDbContext;
var model = new ApiPostClientRequestModel();
model.SetProperties(2, 2, "B", DateTime.Parse("1/1/1988 12:00:00 AM"), 2, DateTime.Parse("1/1/1988 12:00:00 AM"), DateTime.Parse("1/1/1988 12:00:00 AM"), 2, DateTime.Parse("1/1/1988 12:00:00 AM"), DateTime.Parse("1/1/1988 12:00:00 AM"), "B", 1, 1, 1, 1, 2, "B", "B", 2);
var model2 = new ApiPostClientRequestModel();
model2.SetProperties(3, 3, "C", DateTime.Parse("1/1/1989 12:00:00 AM"), 3, DateTime.Parse("1/1/1989 12:00:00 AM"), DateTime.Parse("1/1/1989 12:00:00 AM"), 3, DateTime.Parse("1/1/1989 12:00:00 AM"), DateTime.Parse("1/1/1989 12:00:00 AM"), "C", 1, 1, 1, 1, 3, "C", "C", 3);
var request = new List <ApiPostClientRequestModel>()
{
model, model2
};
CreateResponse <List <ApiPostClientResponseModel> > result = await client.PostBulkInsertAsync(request);
result.Success.Should().BeTrue();
result.Record.Should().NotBeNull();
context.Set <Post>().ToList()[1].AcceptedAnswerId.Should().Be(2);
context.Set <Post>().ToList()[1].AnswerCount.Should().Be(2);
context.Set <Post>().ToList()[1].Body.Should().Be("B");
context.Set <Post>().ToList()[1].ClosedDate.Should().Be(DateTime.Parse("1/1/1988 12:00:00 AM"));
context.Set <Post>().ToList()[1].CommentCount.Should().Be(2);
context.Set <Post>().ToList()[1].CommunityOwnedDate.Should().Be(DateTime.Parse("1/1/1988 12:00:00 AM"));
context.Set <Post>().ToList()[1].CreationDate.Should().Be(DateTime.Parse("1/1/1988 12:00:00 AM"));
context.Set <Post>().ToList()[1].FavoriteCount.Should().Be(2);
context.Set <Post>().ToList()[1].LastActivityDate.Should().Be(DateTime.Parse("1/1/1988 12:00:00 AM"));
context.Set <Post>().ToList()[1].LastEditDate.Should().Be(DateTime.Parse("1/1/1988 12:00:00 AM"));
context.Set <Post>().ToList()[1].LastEditorDisplayName.Should().Be("B");
context.Set <Post>().ToList()[1].LastEditorUserId.Should().Be(1);
context.Set <Post>().ToList()[1].OwnerUserId.Should().Be(1);
context.Set <Post>().ToList()[1].ParentId.Should().Be(1);
context.Set <Post>().ToList()[1].PostTypeId.Should().Be(1);
context.Set <Post>().ToList()[1].Score.Should().Be(2);
context.Set <Post>().ToList()[1].Tag.Should().Be("B");
context.Set <Post>().ToList()[1].Title.Should().Be("B");
context.Set <Post>().ToList()[1].ViewCount.Should().Be(2);
context.Set <Post>().ToList()[2].AcceptedAnswerId.Should().Be(3);
context.Set <Post>().ToList()[2].AnswerCount.Should().Be(3);
context.Set <Post>().ToList()[2].Body.Should().Be("C");
context.Set <Post>().ToList()[2].ClosedDate.Should().Be(DateTime.Parse("1/1/1989 12:00:00 AM"));
context.Set <Post>().ToList()[2].CommentCount.Should().Be(3);
context.Set <Post>().ToList()[2].CommunityOwnedDate.Should().Be(DateTime.Parse("1/1/1989 12:00:00 AM"));
context.Set <Post>().ToList()[2].CreationDate.Should().Be(DateTime.Parse("1/1/1989 12:00:00 AM"));
context.Set <Post>().ToList()[2].FavoriteCount.Should().Be(3);
context.Set <Post>().ToList()[2].LastActivityDate.Should().Be(DateTime.Parse("1/1/1989 12:00:00 AM"));
context.Set <Post>().ToList()[2].LastEditDate.Should().Be(DateTime.Parse("1/1/1989 12:00:00 AM"));
context.Set <Post>().ToList()[2].LastEditorDisplayName.Should().Be("C");
context.Set <Post>().ToList()[2].LastEditorUserId.Should().Be(1);
context.Set <Post>().ToList()[2].OwnerUserId.Should().Be(1);
context.Set <Post>().ToList()[2].ParentId.Should().Be(1);
context.Set <Post>().ToList()[2].PostTypeId.Should().Be(1);
context.Set <Post>().ToList()[2].Score.Should().Be(3);
context.Set <Post>().ToList()[2].Tag.Should().Be("C");
context.Set <Post>().ToList()[2].Title.Should().Be("C");
context.Set <Post>().ToList()[2].ViewCount.Should().Be(3);
}
public ActionResult ViewMemoDetails(string memoseries, int status)
{
XmlConfigurator.Configure();
LoginController ctr = new LoginController();
CreateResponse resp = new CreateResponse();
CreateResponse details = new CreateResponse();
HomeViewModel sss = new HomeViewModel();
List <Signatories> sign;
//get signatories
CreateResponse signatories = ctr.getSignatoryList();
sign = signatories.SignatoryList;
var source = new System.Uri(service + "/CurrentStatusMemoDetails/?memoSeries=" + memoseries + "&status=" + status);
var reqHandler = new RequestHandler("GET", source, "application/json", null);
var response = reqHandler.HttpGetRequest();
resp = Newtonsoft.Json.JsonConvert.DeserializeObject <CreateResponse>(response);
log.Info(JsonConvert.SerializeObject(resp, Formatting.None).ToString());
if (resp.ResponseCode == 200)
{
details.status = Convert.ToInt32(status);
sss.OperatorName = resp.MemoRequestDetails.OperatorName;
sss.DebtCredNo = resp.MemoRequestDetails.MemoSeries;
sss.IRNo = resp.MemoRequestDetails.IRNumber;
sss.DebitCredit = resp.MemoRequestDetails.TransactionType;
sss.WrongAmount = String.IsNullOrEmpty(resp.MemoRequestDetails.Reason1) ? false : true;
sss.Erroneous = String.IsNullOrEmpty(resp.MemoRequestDetails.Reason2) ? false : true;
sss.SystemError = String.IsNullOrEmpty(resp.MemoRequestDetails.Reason3) ? false : true;
sss.TransactionDate1 = resp.MemoRequestDetails.TransactionDate1;
sss.TransactionDate2 = resp.MemoRequestDetails.TransactionDate2;
sss.TransactionDate3 = resp.MemoRequestDetails.TransactionDate3;
sss.refno1 = resp.MemoRequestDetails.ReferenceNo1;
sss.refno2 = resp.MemoRequestDetails.ReferenceNo2;
sss.refno3 = resp.MemoRequestDetails.ReferenceNo3;
sss.WalletUser = resp.MemoRequestDetails.WalletUser;
sss.WalletID = resp.MemoRequestDetails.WalletID;
sss.AdjustAmount = Convert.ToDecimal(resp.MemoRequestDetails.AdjustedAmount);
sss.CorrectAmount = Convert.ToDecimal(resp.MemoRequestDetails.CorrectAmount);
sss.IncorrectAmount = Convert.ToDecimal(resp.MemoRequestDetails.WrongAmount);
sss.File = !String.IsNullOrEmpty(resp.MemoRequestDetails.File) ? resp.MemoRequestDetails.MemoSeries + "_Attachment" : "No file attached.";
sss.FileValue = !String.IsNullOrEmpty(resp.MemoRequestDetails.File) ? resp.MemoRequestDetails.File : "";
sss.FileType = resp.MemoRequestDetails.FileType;
sss.Created_at = resp.MemoRequestDetails.Created_at;
sss.Noted_at = resp.MemoRequestDetails.Noted_at;
sss.Received_at = resp.MemoRequestDetails.Received_at;
sss.Audited_at = resp.MemoRequestDetails.Audited_at;
details.MemoRequestDetails = resp.MemoRequestDetails;
details.SignatoryList = sign;
details.details = sss;
Session["RequestDetailsX"] = details;
log.Info(JsonConvert.SerializeObject(details, Formatting.None).ToString());
return(View());
}
else
{
return(RedirectToAction("ErrorPage"));
}
}
private CreateResponse ExecuteInternal(CreateRequest request)
{
var response = new CreateResponse();
response.Results["id"] = Create(request.Target);
return response;
}
private OrganizationResponse ToOrgResponse(OrganizationRequest orgRequest, HttpResponseMessage result)
{
if (result.StatusCode == HttpStatusCode.InternalServerError)
{
var body = result.Content.ReadAsStringAsync().Result;
throw new Exception("Error from Web API.");
}
var json = result.Content.ReadAsStringAsync().Result;
switch (orgRequest)
{
case RetrieveRequest request:
{
var target = request.Target;
var metadata = _metadata[target.LogicalName];
var entity = JsonConvert.DeserializeObject <Entity>(json, new EntityConverter(metadata));
var response = new RetrieveResponse();
response.Results["Entity"] = entity;
return(response);
}
case RetrieveMultipleRequest request:
{
EntityMetadata metadata;
switch (request.Query)
{
case QueryExpression query:
{
metadata = _metadata[query.EntityName];
break;
}
case QueryByAttribute query:
{
metadata = _metadata[query.EntityName];
break;
}
case FetchExpression query:
{
using (var input = new StringReader(query.Query))
using (var reader = XmlReader.Create(input))
{
reader.ReadToFollowing("entity");
var entityName = reader.GetAttribute("name");
metadata = _metadata[entityName];
break;
}
}
default:
{
throw new NotSupportedException("Query type is not supported.");
}
}
var converters = new JsonConverter[] { new EntityConverter(metadata), new EntityCollectionConverter(metadata) };
var collection = JsonConvert.DeserializeObject <EntityCollection>(json, converters);
var response = new RetrieveMultipleResponse();
response.Results["EntityCollection"] = collection;
return(response);
}
case CreateRequest request:
{
var response = new CreateResponse();
response.Results["Id"] = new Guid();
return(response);
}
case DeleteRequest request:
{
return(null);
}
}
//if (response.RequestMessage.Method == HttpMethod.Get)
//{
// if (response.RequestMessage.RequestUri.AbsolutePath.Contains("("))
// {
// }
// else
// {
// var serializer = new JsonSerializer();
// using (var stream = response.Content.ReadAsStreamAsync().Result)
// using (var sr = new StreamReader(stream))
// using (var jsonTextReader = new JsonTextReader(sr))
// {
// return serializer.Deserialize(jsonTextReader);
// }
// }
//}
//else
//{
return(null);
//}
}
public void Should_Be_Able_To_Execute_An_Insert_With_Output_Clause_And_Get_Back_Values()
{
// Arrange
using (var sandbox = ConnectionTestsSandbox.Create())
{
var dbConnection = sandbox.Container.Resolve <CrmDbConnection>();
var insertCommand = new CrmDbCommand(dbConnection);
insertCommand.CommandText = "INSERT INTO contact (contactid, firstname, lastname) OUTPUT INSERTED.createdon, INSERTED.contactid VALUES ('9bf20a16-6034-48e2-80b4-8349bb80c3e2','JO','SCHMO')";
insertCommand.CommandType = System.Data.CommandType.Text;
var provider = new SqlGenerationCrmOperationProvider(new DynamicsAttributeTypeProvider());
var orgCommand = provider.GetOperation(insertCommand, System.Data.CommandBehavior.Default);
// This is a fake CreateResponse that will be returned to our sut at test time.
Guid expectedId = Guid.Parse("9bf20a16-6034-48e2-80b4-8349bb80c3e2");
var createResponse = new CreateResponse
{
Results = new ParameterCollection
{
{ "id", expectedId }
}
};
// This is a fake RetrieveResponse that will be returned to our sut at test time.
var resultEntity = new Entity("contact");
resultEntity.Id = expectedId;
resultEntity["contactid"] = expectedId;
var createdOnDate = DateTime.UtcNow;
resultEntity["createdon"] = createdOnDate;
var retrieveResponse = new RetrieveResponse
{
Results = new ParameterCollection
{
{ "Entity", resultEntity }
}
};
// This is a fake ExecuteMultipleResponse that will be returned to our sut at test time.
var responses = new ExecuteMultipleResponseItemCollection();
var createResponseItem = new ExecuteMultipleResponseItem();
createResponseItem.RequestIndex = 0;
createResponseItem.Response = createResponse;
responses.Add(createResponseItem);
var retrieveResponseItem = new ExecuteMultipleResponseItem();
retrieveResponseItem.RequestIndex = 1;
retrieveResponseItem.Response = retrieveResponse;
responses.Add(retrieveResponseItem);
var executeMultipleResponse = new ExecuteMultipleResponse
{
Results = new ParameterCollection
{
{ "Responses", responses },
{ "IsFaulted", false }
}
};
// Setup fake org service to return fake response.
sandbox.FakeOrgService.Stub(f => f.Execute(Arg <OrganizationRequest> .Matches(new OrganizationRequestMessageConstraint <ExecuteMultipleRequest>())))
.WhenCalled(x =>
{
var request = ((ExecuteMultipleRequest)x.Arguments[0]);
}).Return(executeMultipleResponse);
// Act
var sut = CrmOperationExecutor.Instance;
dbConnection.Open();
var commandResult = sut.ExecuteOperation(orgCommand);
var results = commandResult.ResultSet;
// Assert
// Should have 1 result, with the 2 output fields - createdon, and contactid
Assert.That(results.ResultCount() == 1);
Assert.That(results.HasColumnMetadata());
var reader = commandResult.GetReader();
Assert.That(reader.HasRows);
Assert.That(reader.FieldCount == 2);
while (reader.Read())
{
Assert.That(reader.GetDateTime(0), NUnit.Framework.Is.EqualTo(createdOnDate));
Assert.That(reader.GetGuid(1), NUnit.Framework.Is.EqualTo(expectedId));
}
}
}
private OrganizationResponse CallOrganizationServiceRequestForExecuteRequest(OrganizationRequest request)
{
OrganizationResponse response = null;
var associate = request as AssociateRequest;
if (associate != null)
{
response = new AssociateResponse();
Associate(associate.Target.LogicalName, associate.Target.Id, associate.Relationship, associate.RelatedEntities);
}
var create = request as CreateRequest;
if (create != null)
{
response = new CreateResponse();
response["id"] = Create(create.Target);
}
var delete = request as DeleteRequest;
if (delete != null)
{
response = new DeleteResponse();
Delete(delete.Target.LogicalName, delete.Target.Id);
}
var disassociate = request as DisassociateRequest;
if (disassociate != null)
{
response = new AssociateResponse();
Disassociate(disassociate.Target.LogicalName, disassociate.Target.Id, disassociate.Relationship, disassociate.RelatedEntities);
}
var retrieve = request as RetrieveRequest;
if (retrieve != null)
{
response = new RetrieveResponse();
response["Entity"] = Retrieve(retrieve.Target.LogicalName, retrieve.Target.Id, retrieve.ColumnSet);
}
var retrieveMultiple = request as RetrieveMultipleRequest;
if (retrieveMultiple != null)
{
response = new RetrieveMultipleResponse();
response["EntityCollection"] = RetrieveMultiple(retrieveMultiple.Query);
}
var update = request as UpdateRequest;
if (update != null)
{
response = new UpdateResponse();
Update(update.Target);
}
return response;
}
public System.IO.Stream Create(double rubAmount, string phoneFrom, string forwardtobtc = null, int dempingpercent = 0, int forwardint = 0, string forwardfraction = "0")
{
long startTime = Now();
try
{
if (!App.credentials.IsAllow("create"))
{
return(null);
}
string requestStr = @"{ rubAmount : '@rubAmount', phoneFrom : '@phoneFrom', forwardtobtc : '@forwardtobtc', dempingpercent : '@dempingpercent', forwardint : '@forwardint', forwardfraction : '@forwardfraction' }"
.Replace("@rubAmount", rubAmount.ToString())
.Replace("@phoneFrom", phoneFrom)
.Replace("@forwardtobtc", forwardtobtc)
.Replace("@dempingpercent", dempingpercent.ToString())
.Replace("@forwardint", forwardint.ToString())
.Replace("@forwardfraction", forwardfraction);
long requestId = (new LogRequestModel(App.db))
.SetRequest("create: " + rubAmount.ToString(), requestStr);
//ждем курсов
int waitRateCnt = 10;
while (App.LAST_PARSED_RATE == null)
{
Thread.Sleep(1000);
if (waitRateCnt-- < 0)
{
return(null);
}
}
//все доступные клиенты на случай неудачи
for (int clientId = 0; clientId < App.LAST_PARSED_RATE.clients.Count; clientId++)
{
//max_repeat_on_fault кол-во попыток
int cntTryOnClient = App.LAST_PARSED_RATE.client.max_repeat_on_fault == -1 ? 1 : App.LAST_PARSED_RATE.client.max_repeat_on_fault;
for (int i = 0; i < cntTryOnClient; i++)
{
string addresstype = App.LAST_PARSED_RATE.client.GetTypeBtcAddress();
string btcAddr = App.btcAddrStorage.GetOne(addresstype);
(new BtcAddressForwardModel(App.db))
.Create(btcAddr, forwardtobtc, dempingpercent, forwardint, forwardfraction);
CreateResponse reseponse = null;
try
{
bool isExpire;
reseponse = _create(out isExpire, startTime, btcAddr, rubAmount, PhoneHelper.PhoneReplacer(phoneFrom), forwardtobtc, dempingpercent, forwardint, forwardfraction);
if (isExpire)
{
return(null);
}
}
catch (Exception) { reseponse = null; }
try {
string jsonResponse = "";
//не пытаемся получить результат, парсим email
if (App.LAST_PARSED_RATE.client.max_repeat_on_fault == -1)
{
jsonResponse = _getResultByEmail(requestId, startTime, btcAddr, rubAmount, phoneFrom, forwardtobtc, dempingpercent, forwardint, forwardfraction);
}
else
{
//если ответ неудачный, повторяем попытку
if (reseponse == null || !reseponse.IsValide())
{
continue;
}
reseponse.client = App.LAST_PARSED_RATE.ToShort();
reseponse.other = new List <KeyValuePair <string, string> > {
new KeyValuePair <string, string>("type_get", "simple")
}.ToArray();
jsonResponse = reseponse.toJson();
(new LogRequestModel(App.db))
.SetResponse(requestId, jsonResponse);
}
WebOperationContext.Current.OutgoingResponse.ContentType = "application/json";
return(new MemoryStream(Encoding.UTF8.GetBytes(jsonResponse)));
} catch (Exception ex) { }
if (App.LAST_PARSED_RATE.client.max_repeat_on_fault == -1)
{
return(null);
}
}
if (!App.LAST_PARSED_RATE.client.allow_switch_to_next_client_on_fault)
{
return(null);
}
//все попытки завершились неудачей, переключим на следующий клиент
App.LAST_PARSED_RATE.Switch();
}
}
catch (Exception) { }
return(null);
}
public async Task CreateAnUpdateMultiple()
{
ForceClient client = await forceClientFixture.GetForceClient();
//create new object
SfAccount firstAccount = new SfAccount()
{
};
string firstAccountName = string.Format("Test Object {0}", Guid.NewGuid().ToString());
firstAccount.Name = firstAccountName;
CreateResponse createResp = await client.CreateRecord <SfAccount>(SfAccount.SObjectTypeName, firstAccount);
string firstAccountId = createResp.Id;
Assert.True(!string.IsNullOrEmpty(createResp.Id), "Failed to create new object");
//get new object
firstAccount = await client.GetObjectById <SfAccount>(SfAccount.SObjectTypeName, firstAccountId);
//create second new object for testing update multiple
SfAccount secondAccount = new SfAccount();
string secondAccountName = string.Format("Test Object {0}", Guid.NewGuid().ToString());
secondAccount.Name = secondAccountName;
CreateResponse secondCreateResp = await client.CreateRecord <SfAccount>(SfAccount.SObjectTypeName, secondAccount);
string secondAccountId = secondCreateResp.Id;
Assert.True(!string.IsNullOrEmpty(secondCreateResp.Id), "Failed to create second new object");
//get new object
secondAccount = await client.GetObjectById <SfAccount>(SfAccount.SObjectTypeName, secondAccountId);
//test update multiple
string firstUpdatedDescription = string.Format("Test Description {0}", Guid.NewGuid().ToString());
string secondUpdatedDescription = string.Format("Test Description {0}", Guid.NewGuid().ToString());
firstAccount.Description = firstUpdatedDescription;
secondAccount.Description = secondUpdatedDescription;
try
{
List <UpdateMultipleResponse> responses = await client.UpdateRecords(new List <SObject>() { firstAccount, secondAccount }, true);
Assert.True(responses.All(r => r.Success), "Failed to update multiple objects");
}
catch (Exception ex)
{
throw ex;
}
//get newly updated objects
string secondNewAccountId = secondCreateResp.Id;
SfAccount firstUpdatedAccount = await client.GetObjectById <SfAccount>(SfAccount.SObjectTypeName, firstAccountId);
SfAccount secondUpdatedAccount = await client.GetObjectById <SfAccount>(SfAccount.SObjectTypeName, secondAccountId);
Assert.True(firstUpdatedAccount != null && secondUpdatedAccount != null, "Failed to retrieve multiple updated objects");
Assert.Equal(firstUpdatedDescription, firstUpdatedAccount.Description);
Assert.Equal(secondUpdatedDescription, secondUpdatedAccount.Description);
//delete
await client.DeleteRecord(SfAccount.SObjectTypeName, firstAccountId);
await client.DeleteRecord(SfAccount.SObjectTypeName, secondNewAccountId);
//use queryall to find deleted record
}
public OrganizationResponse Execute( OrganizationRequest request )
{
if( request.GetType().Name == "RetrieveMultipleRequest" ) {
RetrieveMultipleResponse response = new RetrieveMultipleResponse();
EntityCollection result = RetrieveMultiple( ( ( RetrieveMultipleRequest )request ).Query );
response.Results[ "EntityCollection" ] = result;
return response;
}
else if(request.GetType().Name == "RetrieveRequest" ) {
RetrieveResponse response = new RetrieveResponse();
RetrieveRequest retrieveRequest = ( RetrieveRequest )request;
EntityReference target = retrieveRequest.Target;
if( target.GetType().Name == "TargetRetrieveDynamic" ) {
/*
TargetRetrieveDynamic trd = ( TargetRetrieveDynamic )target;
response.Entity = Retrieve( trd.EntityName, trd.EntityId, retrieveRequest.ColumnSet );
*/
}
// TODO: entity is readonly .. will have to set this with reflection
// response.Entity = Retrieve( target.LogicalName, target.Id, retrieveRequest.ColumnSet );
else {
// request sent using a specific strongly-typed business entity
// rather than a DynamicEntity
throw new NotImplementedException();
}
return response;
}
else if( request.GetType().Name == "CreateRequest" ) {
CreateResponse response = new CreateResponse();
Guid result = Create( ( ( CreateRequest )request ).Target );
response.Results[ "id" ] = result;
return response;
}
else if( request.GetType().Name == "UpdateRequest" ) {
UpdateResponse response = new UpdateResponse();
Update( ( ( UpdateRequest )request).Target );
return response;
}
else {
throw new NotImplementedException();
}
}
private void describe_()
{
ContainersController containersController = null;
Mock <IContainerService> mockContainerService = null;
Mock <ILogger> mockLogger = null;
before = () =>
{
mockContainerService = new Mock <IContainerService>();
mockLogger = new Mock <ILogger>();
containersController = new ContainersController(mockContainerService.Object, mockLogger.Object)
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage()
};
};
describe[Controller.Index] = () =>
{
IReadOnlyList <string> result = null;
Mock <IContainer> mockContainer1 = null;
before = () =>
{
mockContainer1 = mockContainerWithHandle("handle1");
var mockContainer2 = mockContainerWithHandle("handle2");
var mockContainer3 = mockContainerWithHandle("handle3");
mockContainerService.Setup(x => x.GetContainers())
.Returns(new List <IContainer>
{
mockContainer1.Object,
mockContainer2.Object,
mockContainer3.Object
});
mockContainer1.Setup(x => x.GetProperties()).Returns(new Dictionary <string, string> {
{ "a", "b" }
});
mockContainer2.Setup(x => x.GetProperties()).Returns(new Dictionary <string, string> {
{ "a", "b" }, { "c", "d" }, { "e", "f" }
});
mockContainer3.Setup(x => x.GetProperties()).Returns(new Dictionary <string, string> {
{ "e", "f" }
});
};
it["when filter is provided returns a filtered list of container id's as strings"] = () =>
{
result = containersController.Index("{\"a\":\"b\", \"e\":\"f\"}");
result.should_not_be_null();
result.Count.should_be(1);
result.should_contain("handle2");
};
it["without filter returns a list of all containers id's as strings"] = () =>
{
result = containersController.Index();
result.should_not_be_null();
result.Count.should_be(3);
result.should_contain("handle1");
result.should_contain("handle2");
result.should_contain("handle3");
};
it["filters out destroyed containers when a query is passed"] = () =>
{
mockContainer1.Setup(x => x.GetProperties()).Returns(() => { throw new InvalidOperationException(); });
result = containersController.Index("{}");
result.should_not_contain("handle1");
result.should_contain("handle2");
result.should_contain("handle3");
};
};
describe["#Create"] = () =>
{
Mock <IContainer> mockContainer = null;
ContainerSpecApiModel containerSpec = null;
before = () =>
{
mockContainer = mockContainerWithHandle("thisHandle");
containerSpec = new ContainerSpecApiModel
{
Limits = new Limits
{
MemoryLimits = new MemoryLimits {
LimitInBytes = 500
},
CpuLimits = new CpuLimits {
Weight = 5
},
DiskLimits = new DiskLimits {
ByteHard = 999
}
}
};
};
context["on success"] = () =>
{
before = () =>
{
mockContainerService.Setup(x => x.CreateContainer(It.IsAny <ContainerSpec>()))
.Returns(mockContainer.Object);
};
it["returns a handle"] = () =>
{
var result = containersController.Create(containerSpec);
result.Handle.should_be("thisHandle");
};
it["sets ActiveProcessLimit on the Container"] = () =>
{
containersController.Create(containerSpec);
mockContainer.Verify(x => x.SetActiveProcessLimit(10));
};
it["sets PriorityClass on the Container"] = () =>
{
containersController.Create(containerSpec);
mockContainer.Verify(x => x.SetPriorityClass(ProcessPriorityClass.BelowNormal));
};
it["sets limits on the container"] = () =>
{
containersController.Create(containerSpec);
mockContainer.Verify(x => x.LimitMemory(500));
mockContainer.Verify(x => x.LimitCpu(5));
mockContainer.Verify(x => x.LimitDisk(999));
};
it["doesn't set limits when the values are null"] = () =>
{
containerSpec.Limits.MemoryLimits.LimitInBytes = null;
containerSpec.Limits.CpuLimits.Weight = null;
containerSpec.Limits.DiskLimits.ByteHard = null;
containersController.Create(containerSpec);
mockContainer.Verify(x => x.LimitMemory(It.IsAny <ulong>()), Times.Never());
mockContainer.Verify(x => x.LimitCpu(It.IsAny <int>()), Times.Never());
mockContainer.Verify(x => x.LimitDisk(It.IsAny <ulong>()), Times.Never());
};
};
context["on failure"] = () =>
{
before = () => mockContainerService.Setup(x => x.CreateContainer(It.IsAny <ContainerSpec>())).Throws(new Exception());
it["throws HttpResponseException"] = () =>
{
expect <HttpResponseException>(() => containersController.Create(containerSpec));
};
};
};
describe["#NetIn"] = () =>
{
string containerHandle = null;
string containerPath = null;
ContainerSpecApiModel specModel = null;
CreateResponse result = null;
Mock <IContainer> mockContainer = null;
string key = null;
string value = null;
context["when the container is created successfully"] = () =>
{
before = () =>
{
containerHandle = Guid.NewGuid().ToString();
containerPath = Path.Combine(@"C:\containerizer", containerHandle);
mockContainer = new Mock <IContainer>();
mockContainer.Setup(x => x.Handle).Returns(containerHandle);
mockContainerService.Setup(x => x.CreateContainer(It.IsAny <ContainerSpec>()))
.Returns(mockContainer.Object);
key = "hiwillyou";
value = "bemyfriend";
specModel = new ContainerSpecApiModel
{
Handle = containerHandle,
Properties = new Dictionary <string, string>
{
{ key, value }
}
};
};
act = () => result = containersController.Create(specModel);
it["returns the passed in container's id"] = () =>
{
result.Handle.should_be(containerHandle);
};
it["sets properties"] = () =>
{
mockContainerService.Verify(
x => x.CreateContainer(
It.Is <ContainerSpec>(createSpec => createSpec.Properties[key] == value)));
};
context["when properties are not passed to the endpoint"] = () =>
{
before = () =>
{
specModel = new ContainerSpecApiModel
{
Handle = containerHandle,
Properties = null,
};
};
it["returns the passed in container's id"] = () =>
{
result.Handle.should_be(containerHandle);
};
};
};
context["when creating a container fails"] = () =>
{
Exception ex = null;
act = () =>
{
try
{
containersController.Create(new ContainerSpecApiModel()
{
Handle = "foo"
});
}
catch (Exception e)
{
ex = e;
}
};
context["because the user already exists"] = () =>
{
before = () =>
{
mockContainerService.Setup(x => x.CreateContainer(It.IsAny <ContainerSpec>()))
.Throws(new PrincipalExistsException());
};
it["throw HttpResponseException with handle already exists message"] = () =>
{
var httpResponse = ex.should_cast_to <HttpResponseException>();
httpResponse.Response.StatusCode.should_be(HttpStatusCode.Conflict);
httpResponse.Response.Content.ReadAsJsonString().should_be("handle already exists: foo");
};
};
context["because other random exception"] = () =>
{
before = () =>
{
mockContainerService.Setup(x => x.CreateContainer(It.IsAny <ContainerSpec>())).Throws(new Exception("BOOM"));
};
it["throw HttpResponseException with the original exception's message"] = () =>
{
var httpResponse = ex.should_cast_to <HttpResponseException>();
httpResponse.Response.StatusCode.should_be(HttpStatusCode.InternalServerError);
httpResponse.Response.Content.ReadAsJsonString().should_be("BOOM");
};
};
};
};
describe["#Stop"] = () =>
{
IHttpActionResult result = null;
act = () => result = containersController.Stop("MySecondContainer");
context["a handle which exists"] = () =>
{
Mock <IContainer> mockContainer = null;
before = () =>
{
mockContainer = new Mock <IContainer>();
mockContainerService.Setup(x => x.GetContainerByHandle("MySecondContainer")).Returns(mockContainer.Object);
};
it["returns 200"] = () =>
{
result.should_cast_to <System.Web.Http.Results.OkResult>();
};
it["calls stop on the container"] = () =>
{
mockContainer.Verify(x => x.Stop(true));
};
};
context["a handle which does not exist"] = () =>
{
before = () =>
{
mockContainerService.Setup(x => x.GetContainerByHandle("MySecondContainer")).Returns(null as IContainer);
};
it["returns 404"] = () =>
{
result.should_cast_to <System.Web.Http.Results.NotFoundResult>();
};
};
};
describe["#Destroy"] = () =>
{
IHttpActionResult result = null;
act = () => result = containersController.Destroy("MySecondContainer");
context["a handle which exists"] = () =>
{
Mock <IContainer> mockContainer = null;
before = () =>
{
mockContainer = new Mock <IContainer>();
mockContainerService.Setup(x => x.GetContainerByHandle("MySecondContainer")).Returns(mockContainer.Object);
};
it["returns 200"] = () =>
{
result.should_cast_to <System.Web.Http.Results.OkResult>();
};
it["calls delete on the containerPathService"] = () =>
{
mockContainerService.Verify(x => x.DestroyContainer("MySecondContainer"));
};
};
context["a handle which does not exist"] = () =>
{
before = () =>
{
mockContainerService.Setup(x => x.GetContainerByHandle("MySecondContainer")).Returns(null as IContainer);
};
it["returns 404"] = () =>
{
result.should_cast_to <System.Web.Http.Results.NotFoundResult>();
};
};
};
}
public void CreateRequestTests()
{
Mock <IOrganizationService> orgSvc = null;
Mock <MoqHttpMessagehander> fakHttpMethodHander = null;
ServiceClient cli = null;
testSupport.SetupMockAndSupport(out orgSvc, out fakHttpMethodHander, out cli);
// Set up Responses
CreateResponse testCreate = new CreateResponse();
testCreate.Results.AddOrUpdateIfNotNull("accountid", testSupport._DefaultId);
testCreate.Results.AddOrUpdateIfNotNull("id", testSupport._DefaultId);
HttpResponseMessage createRespMsg = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
createRespMsg.Headers.Add("Location", $"https://deploymenttarget02.crm.dynamics.com/api/data/v9.1/accounts({testSupport._DefaultId})");
createRespMsg.Headers.Add("OData-EntityId", $"https://deploymenttarget02.crm.dynamics.com/api/data/v9.1/accounts({testSupport._DefaultId})");
// Setup handlers to deal with both orgRequest and WebAPI request.
fakHttpMethodHander.Setup(s => s.Send(It.Is <HttpRequestMessage>(f => f.Method.ToString().Equals("post", StringComparison.OrdinalIgnoreCase)))).Returns(createRespMsg);
orgSvc.Setup(f => f.Execute(It.Is <CreateRequest>(p => p.Target.LogicalName.Equals("account")))).Returns(testCreate);
// Setup request
// use create operation to setup request
Dictionary <string, DataverseDataTypeWrapper> newFields = new Dictionary <string, DataverseDataTypeWrapper>();
newFields.Add("name", new DataverseDataTypeWrapper("CrudTestAccount", DataverseFieldType.String));
newFields.Add("dateonlyfield", new DataverseDataTypeWrapper(new DateTime(2000, 01, 01), DataverseFieldType.DateTime));
newFields.Add("datetimeNormal", new DataverseDataTypeWrapper(new DateTime(2000, 01, 01, 12, 01, 00, DateTimeKind.Local), DataverseFieldType.DateTime));
newFields.Add("datetimeTZindependant", new DataverseDataTypeWrapper(new DateTime(2000, 01, 01, 13, 01, 00, DateTimeKind.Local), DataverseFieldType.DateTime));
Entity acctEntity = new Entity("account");
acctEntity.Attributes.Add("name", "CrudTestAccount");
acctEntity.Attributes.Add("dateonlyfield", new DateTime(2000, 01, 01));
acctEntity.Attributes.Add("datetimeNormal", new DateTime(2000, 01, 01, 12, 01, 00, DateTimeKind.Local));
acctEntity.Attributes.Add("datetimeTZindependant", new DateTime(2000, 01, 01, 13, 01, 00, DateTimeKind.Local));
Guid respId = Guid.Empty;
// Test entity create
var response = cli.ExecuteOrganizationRequest(new CreateRequest()
{
Target = acctEntity
}, useWebAPI: false);
Assert.NotNull(response);
respId = ((CreateResponse)response).id;
Assert.Equal(testSupport._DefaultId, respId);
// Test low level create
respId = cli.Create(acctEntity);
Assert.Equal(testSupport._DefaultId, respId);
// Test Helper create
respId = cli.CreateNewRecord("account", newFields);
Assert.Equal(testSupport._DefaultId, respId);
}
/// <summary>
/// This method first connects to the Organization service. Afterwards,
/// basic create, retrieve, update, and delete entity operations are performed.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
try
{
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = ServerConnection.GetOrganizationProxy(serverConfig))
{
// This statement is required to enable early-bound type support.
_serviceProxy.EnableProxyTypes();
CreateRequiredRecords();
//<snippetImportWebResources1>
//Read the descriptive data from the XML file
XDocument xmlDoc = XDocument.Load("../../ImportJob.xml");
//Create a collection of anonymous type references to each of the Web Resources
var webResources = from webResource in xmlDoc.Descendants("webResource")
select new
{
path = webResource.Element("path").Value,
displayName = webResource.Element("displayName").Value,
description = webResource.Element("description").Value,
name = webResource.Element("name").Value,
type = webResource.Element("type").Value
};
// Loop through the collection creating Web Resources
int counter = 0;
foreach (var webResource in webResources)
{
//<snippetImportWebResources2>
//Set the Web Resource properties
WebResource wr = new WebResource
{
Content = getEncodedFileContents(@"../../" + webResource.path),
DisplayName = webResource.displayName,
Description = webResource.description,
Name = _customizationPrefix + webResource.name,
LogicalName = WebResource.EntityLogicalName,
WebResourceType = new OptionSetValue(Int32.Parse(webResource.type))
};
// Using CreateRequest because we want to add an optional parameter
CreateRequest cr = new CreateRequest
{
Target = wr
};
//Set the SolutionUniqueName optional parameter so the Web Resources will be
// created in the context of a specific solution.
cr.Parameters.Add("SolutionUniqueName", _ImportWebResourcesSolutionUniqueName);
CreateResponse cresp = (CreateResponse)_serviceProxy.Execute(cr);
//</snippetImportWebResources2>
// Capture the id values for the Web Resources so the sample can delete them.
_webResourceIds[counter] = cresp.id;
counter++;
Console.WriteLine("Created Web Resource: {0}", webResource.displayName);
}
//</snippetImportWebResources1>
DeleteRequiredRecords(promptforDelete);
}
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException <Microsoft.Xrm.Sdk.OrganizationServiceFault> )
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
public virtual async void TestBulkInsert()
{
var builder = new WebHostBuilder()
.UseEnvironment("Production")
.UseStartup <TestStartup>();
TestServer testServer = new TestServer(builder);
var client = new ApiClient(testServer.CreateClient());
client.SetBearerToken(JWTTestHelper.GenerateBearerToken());
ApplicationDbContext context = testServer.Host.Services.GetService(typeof(ApplicationDbContext)) as ApplicationDbContext;
var model = new ApiPipelineStepStepRequirementClientRequestModel();
model.SetProperties("B", 1, true);
var model2 = new ApiPipelineStepStepRequirementClientRequestModel();
model2.SetProperties("C", 1, true);
var request = new List <ApiPipelineStepStepRequirementClientRequestModel>()
{
model, model2
};
CreateResponse <List <ApiPipelineStepStepRequirementClientResponseModel> > result = await client.PipelineStepStepRequirementBulkInsertAsync(request);
result.Success.Should().BeTrue();
result.Record.Should().NotBeNull();
context.Set <PipelineStepStepRequirement>().ToList()[1].Details.Should().Be("B");
context.Set <PipelineStepStepRequirement>().ToList()[1].PipelineStepId.Should().Be(1);
context.Set <PipelineStepStepRequirement>().ToList()[1].RequirementMet.Should().Be(true);
context.Set <PipelineStepStepRequirement>().ToList()[2].Details.Should().Be("C");
context.Set <PipelineStepStepRequirement>().ToList()[2].PipelineStepId.Should().Be(1);
context.Set <PipelineStepStepRequirement>().ToList()[2].RequirementMet.Should().Be(true);
}
internal override OrganizationResponse Execute(OrganizationRequest orgRequest, EntityReference userRef)
{
var request = MakeRequest <CreateRequest>(orgRequest);
var resp = new CreateResponse();
var settings = MockupExecutionContext.GetSettings(request);
var entity = request.Target;
if (entity.LogicalName == null)
{
throw new MockupException("Entity needs a logical name");
}
var entityMetadata = metadata.EntityMetadata.GetMetadata(entity.LogicalName);
var clonedEntity = entity.CloneEntity(entityMetadata, new ColumnSet(true));
var validAttributes = clonedEntity.Attributes.Where(x => x.Value != null);
clonedEntity.Attributes = new AttributeCollection();
clonedEntity.Attributes.AddRange(validAttributes);
if (userRef != null && userRef.Id != Guid.Empty && !security.HasPermission(clonedEntity, AccessRights.CreateAccess, userRef))
{
throw new FaultException($"Trying to create entity '{entity.LogicalName}'" +
$", but the calling user with id '{userRef.Id}' does not have create access for that entity");
}
if (Utility.HasCircularReference(metadata.EntityMetadata, clonedEntity))
{
throw new FaultException($"Trying to create entity '{clonedEntity.LogicalName}', but the attributes had a circular reference");
}
var transactioncurrencyId = "transactioncurrencyid";
var exchangerate = "exchangerate";
if (!clonedEntity.Attributes.ContainsKey(transactioncurrencyId) &&
Utility.IsSettableAttribute(transactioncurrencyId, entityMetadata) &&
entityMetadata.Attributes.Any(m => m is MoneyAttributeMetadata) &&
(settings.ServiceRole == MockupServiceSettings.Role.UI ||
(settings.ServiceRole == MockupServiceSettings.Role.SDK && clonedEntity.Attributes.Any(
attr => entityMetadata.Attributes.Where(a => a is MoneyAttributeMetadata).Any(m => m.LogicalName == attr.Key)))))
{
var user = db.GetEntityOrNull(userRef);
if (user.Attributes.ContainsKey(transactioncurrencyId))
{
clonedEntity.Attributes[transactioncurrencyId] = user[transactioncurrencyId];
}
else
{
clonedEntity.Attributes[transactioncurrencyId] = Utility.GetBaseCurrency(metadata);
}
}
if (!clonedEntity.Attributes.ContainsKey(exchangerate) &&
Utility.IsSettableAttribute(exchangerate, entityMetadata) &&
clonedEntity.Attributes.ContainsKey(transactioncurrencyId))
{
var currencyId = clonedEntity.GetAttributeValue <EntityReference>(transactioncurrencyId);
var currency = db.GetEntityOrNull(currencyId);
clonedEntity.Attributes[exchangerate] = currency["exchangerate"];
Utility.HandleCurrencies(metadata, db, clonedEntity);
}
var attributes = entityMetadata.Attributes;
if (!clonedEntity.Attributes.ContainsKey("statecode") &&
Utility.IsSettableAttribute("statecode", entityMetadata))
{
var stateMeta = attributes.First(a => a.LogicalName == "statecode") as StateAttributeMetadata;
clonedEntity["statecode"] = stateMeta.DefaultFormValue.HasValue ? new OptionSetValue(stateMeta.DefaultFormValue.Value) : new OptionSetValue(0);
}
if (!clonedEntity.Attributes.ContainsKey("statuscode") &&
Utility.IsSettableAttribute("statuscode", entityMetadata))
{
var statusMeta = attributes.FirstOrDefault(a => a.LogicalName == "statuscode") as StatusAttributeMetadata;
clonedEntity["statuscode"] = statusMeta.DefaultFormValue.HasValue ? new OptionSetValue(statusMeta.DefaultFormValue.Value) : new OptionSetValue(1);
}
if (Utility.IsSettableAttribute("createdon", entityMetadata))
{
clonedEntity["createdon"] = DateTime.Now.Add(core.TimeOffset);
}
if (Utility.IsSettableAttribute("createdby", entityMetadata))
{
clonedEntity["createdby"] = userRef;
}
if (Utility.IsSettableAttribute("modifiedon", entityMetadata) &&
Utility.IsSettableAttribute("modifiedby", entityMetadata))
{
clonedEntity["modifiedon"] = clonedEntity["createdon"];
clonedEntity["modifiedby"] = clonedEntity["createdby"];
}
var owner = userRef;
if (clonedEntity.Attributes.ContainsKey("ownerid"))
{
owner = clonedEntity.GetAttributeValue <EntityReference>("ownerid");
}
Utility.SetOwner(db, security, metadata, clonedEntity, owner);
if (!clonedEntity.Attributes.ContainsKey("businessunitid") &&
clonedEntity.LogicalName == LogicalNames.SystemUser || clonedEntity.LogicalName == LogicalNames.Team)
{
clonedEntity["businessunitid"] = metadata.RootBusinessUnit.ToEntityReference();
}
if (clonedEntity.LogicalName == LogicalNames.BusinessUnit && !clonedEntity.Attributes.ContainsKey("parentbusinessunitid"))
{
clonedEntity["parentbusinessunitid"] = metadata.RootBusinessUnit.ToEntityReference();
}
if (settings.ServiceRole == MockupServiceSettings.Role.UI)
{
foreach (var attr in entityMetadata.Attributes.Where(a => (a as BooleanAttributeMetadata)?.DefaultValue != null).ToList())
{
if (!clonedEntity.Attributes.Any(a => a.Key == attr.LogicalName))
{
clonedEntity[attr.LogicalName] = (attr as BooleanAttributeMetadata).DefaultValue;
}
}
foreach (var attr in entityMetadata.Attributes.Where(a =>
(a as PicklistAttributeMetadata)?.DefaultFormValue != null && (a as PicklistAttributeMetadata)?.DefaultFormValue.Value != -1).ToList())
{
if (!clonedEntity.Attributes.Any(a => a.Key == attr.LogicalName))
{
clonedEntity[attr.LogicalName] = new OptionSetValue((attr as PicklistAttributeMetadata).DefaultFormValue.Value);
}
}
}
if (clonedEntity.LogicalName == LogicalNames.Contact || clonedEntity.LogicalName == LogicalNames.Lead || clonedEntity.LogicalName == LogicalNames.SystemUser)
{
Utility.SetFullName(metadata, clonedEntity);
}
db.Add(clonedEntity);
if (clonedEntity.LogicalName == LogicalNames.BusinessUnit)
{
security.AddRolesForBusinessUnit(db, clonedEntity.ToEntityReference());
}
if (entity.RelatedEntities.Count > 0)
{
foreach (var relatedEntities in entity.RelatedEntities)
{
if (Utility.GetRelationshipMetadataDefaultNull(metadata.EntityMetadata, relatedEntities.Key.SchemaName, Guid.Empty, userRef) == null)
{
throw new FaultException($"Relationship with schemaname '{relatedEntities.Key.SchemaName}' does not exist in metadata");
}
foreach (var relatedEntity in relatedEntities.Value.Entities)
{
var req = new CreateRequest()
{
Target = relatedEntity
};
core.Execute(req, userRef);
}
var associateReq = new AssociateRequest {
Target = entity.ToEntityReference(),
Relationship = relatedEntities.Key,
RelatedEntities = new EntityReferenceCollection(relatedEntities.Value.Entities.Select(e => e.ToEntityReference()).ToList())
};
core.Execute(associateReq, userRef);
}
}
resp.Results.Add("id", clonedEntity.Id);
return(resp);
}
private OrganizationResponse CallOrganizationServiceRequestForExecuteRequest(OrganizationRequest request)
{
OrganizationResponse response = null;
var associate = request as AssociateRequest;
if (associate != null)
{
response = new AssociateResponse();
Associate(associate.Target.LogicalName, associate.Target.Id, associate.Relationship, associate.RelatedEntities);
}
var create = request as CreateRequest;
if (create != null)
{
response = new CreateResponse {
["id"] = Create(create.Target)
};
}
var delete = request as DeleteRequest;
if (delete != null)
{
response = new DeleteResponse();
Delete(delete.Target.LogicalName, delete.Target.Id);
}
var disassociate = request as DisassociateRequest;
if (disassociate != null)
{
response = new AssociateResponse();
Disassociate(disassociate.Target.LogicalName, disassociate.Target.Id, disassociate.Relationship, disassociate.RelatedEntities);
}
var retrieve = request as RetrieveRequest;
if (retrieve != null)
{
response = new RetrieveResponse {
["Entity"] = Retrieve(retrieve.Target.LogicalName, retrieve.Target.Id, retrieve.ColumnSet)
};
}
var retrieveMultiple = request as RetrieveMultipleRequest;
if (retrieveMultiple != null)
{
response = new RetrieveMultipleResponse {
["EntityCollection"] = RetrieveMultiple(retrieveMultiple.Query)
};
}
var update = request as UpdateRequest;
if (update != null)
{
response = new UpdateResponse();
Update(update.Target);
}
return(response);
}
[STAThread] // Added to support UX
static void Main(string[] args)
{
CrmServiceClient service = null;
try
{
service = SampleHelpers.Connect("Connect");
if (service.IsReady)
{
#region Sample Code
//////////////////////////////////////////////
#region Set up
SetUpSample(service);
#endregion Set up
#region Demonstrate
// Create and account record with the named Proseware, Inc. and already existing Account Number.
var account = new Account
{
Name = "Proseware, Inc.",
AccountNumber = "ACC005"
};
// Create operation by suppressing duplicate detection
var reqCreate = new CreateRequest();
reqCreate.Target = account;
reqCreate.Parameters.Add("SuppressDuplicateDetection", true); // Change to false to activate the duplicate detection.
CreateResponse createResponse = (CreateResponse)service.Execute(reqCreate);
dupAccountId = createResponse.id;
Console.Write("Account: {0} {1} created with SuppressDuplicateDetection to true, ",
account.Name, account.AccountNumber);
// Retrieve the account containing with its few attributes.
ColumnSet cols = new ColumnSet(
new String[] { "name", "accountnumber" });
var retrievedAccount = (Account)service.Retrieve("account", dupAccountId, cols);
Console.Write("retrieved, ");
// Update the existing account with new account number.
retrievedAccount.AccountNumber = "ACC006";
// Update operation – update record, if a duplicate is not found.
UpdateRequest reqUpdate = new UpdateRequest();
reqUpdate.Target = retrievedAccount;
reqUpdate["SuppressDuplicateDetection"] = false; // Duplicate detection is activated.
// Update the account record.
var updateResponse = (UpdateResponse)service.Execute(reqUpdate);
Console.WriteLine("and updated.");
#region Clean up
CleanUpSample(service);
#endregion Clean up
}
#endregion Demonstrate
else
{
const string UNABLE_TO_LOGIN_ERROR = "Unable to Login to Common Data Service";
if (service.LastCrmError.Equals(UNABLE_TO_LOGIN_ERROR))
{
Console.WriteLine("Check the connection string values in cds/App.config.");
throw new Exception(service.LastCrmError);
}
else
{
throw service.LastCrmException;
}
}
}
#endregion Sample Code
catch (Exception ex)
{
SampleHelpers.HandleException(ex);
}
finally
{
if (service != null)
{
service.Dispose();
}
Console.WriteLine("Press <Enter> to exit.");
Console.ReadLine();
}
}
public void BatchTest()
{
Mock <IOrganizationService> orgSvc = null;
Mock <MoqHttpMessagehander> fakHttpMethodHander = null;
CdsServiceClient cli = null;
testSupport.SetupMockAndSupport(out orgSvc, out fakHttpMethodHander, out cli);
CreateResponse createResponse = new CreateResponse();
createResponse.Results = new ParameterCollection();
createResponse.Results.Add("annotationid", testSupport._DefaultId);
ExecuteMultipleResponseItem responseItem = new ExecuteMultipleResponseItem();
responseItem.Response = createResponse;
responseItem.RequestIndex = 0;
ExecuteMultipleResponseItemCollection responseItems = new ExecuteMultipleResponseItemCollection();
responseItems.Add(responseItem);
ExecuteMultipleResponse executeMultipleResponse = new ExecuteMultipleResponse();
executeMultipleResponse.Results = new ParameterCollection();
executeMultipleResponse.Results.Add("Responses", responseItems);
orgSvc.Setup(req1 => req1.Execute(It.IsAny <ExecuteMultipleRequest>())).Returns(executeMultipleResponse);
// Setup a batch
string BatchRequestName = "TestBatch";
Guid batchid = cli.CreateBatchOperationRequest(BatchRequestName);
// use create operation to setup request
Dictionary <string, CdsDataTypeWrapper> newFields = new Dictionary <string, CdsDataTypeWrapper>();
newFields.Add("name", new CdsDataTypeWrapper("CrudTestAccount", CdsFieldType.String));
newFields.Add("accountnumber", new CdsDataTypeWrapper("12345", CdsFieldType.String));
newFields.Add("telephone1", new CdsDataTypeWrapper("555-555-5555", CdsFieldType.String));
newFields.Add("donotpostalmail", new CdsDataTypeWrapper(true, CdsFieldType.Boolean));
// issue request as a batch:
Guid result = cli.CreateAnnotation("account", testSupport._DefaultId, newFields, batchid);
Assert.Equal <Guid>(Guid.Empty, result);
OrganizationRequest req = cli.GetBatchRequestAtPosition(batchid, 0);
// Executes the batch request.
cli.ExecuteBatch(batchid);
// Request Batch by name
Guid OperationId = cli.GetBatchOperationIdRequestByName(BatchRequestName);
// Request batch back
RequestBatch reqBatch = cli.GetBatchById(batchid);
Assert.NotNull(reqBatch);
Assert.Equal(BatchRequestName, reqBatch.BatchName);
Assert.True(reqBatch.BatchItems.Count == 1);
// Release batch request
cli.ReleaseBatchInfoById(batchid);
}
public void DataTypeParsingTest()
{
Mock <IOrganizationService> orgSvc = null;
Mock <MoqHttpMessagehander> fakHttpMethodHander = null;
CdsServiceClient cli = null;
testSupport.SetupMockAndSupport(out orgSvc, out fakHttpMethodHander, out cli);
// Set up Responses
CreateResponse testCreate = new CreateResponse();
testCreate.Results.AddOrUpdateIfNotNull("accountid", testSupport._DefaultId);
testCreate.Results.AddOrUpdateIfNotNull("id", testSupport._DefaultId);
HttpResponseMessage createRespMsg = new HttpResponseMessage(System.Net.HttpStatusCode.OK);
createRespMsg.Headers.Add("Location", $"https://deploymenttarget02.crm.dynamics.com/api/data/v9.1/accounts({testSupport._DefaultId})");
createRespMsg.Headers.Add("OData-EntityId", $"https://deploymenttarget02.crm.dynamics.com/api/data/v9.1/accounts({testSupport._DefaultId})");
// Setup handlers to deal with both orgRequest and WebAPI request.
fakHttpMethodHander.Setup(s => s.Send(It.Is <HttpRequestMessage>(f => f.Method.ToString().Equals("post", StringComparison.OrdinalIgnoreCase)))).Returns(createRespMsg);
orgSvc.Setup(f => f.Execute(It.Is <CreateRequest>(p => p.Target.LogicalName.Equals("account")))).Returns(testCreate);
// Setup request for all datatypes
// use create operation to setup request
Dictionary <string, CdsDataTypeWrapper> newFields = new Dictionary <string, CdsDataTypeWrapper>();
newFields.Add("name", new CdsDataTypeWrapper("CrudTestAccount", CdsFieldType.String));
newFields.Add("Field01", new CdsDataTypeWrapper(false, CdsFieldType.Boolean));
newFields.Add("Field02", new CdsDataTypeWrapper(testSupport._DefaultId, CdsFieldType.Customer, "parentaccount"));
newFields.Add("Field03", new CdsDataTypeWrapper(DateTime.UtcNow, CdsFieldType.DateTime));
newFields.Add("Field04", new CdsDataTypeWrapper(64, CdsFieldType.Decimal));
newFields.Add("Field05", new CdsDataTypeWrapper(1.001, CdsFieldType.Float));
newFields.Add("Field06", new CdsDataTypeWrapper(testSupport._DefaultId, CdsFieldType.Key));
newFields.Add("Field07", new CdsDataTypeWrapper(testSupport._DefaultId, CdsFieldType.Lookup, "parentaccount"));
newFields.Add("Field08", new CdsDataTypeWrapper(50, CdsFieldType.Money));
newFields.Add("Field09", new CdsDataTypeWrapper(100, CdsFieldType.Number));
newFields.Add("Field010", new CdsDataTypeWrapper(20, CdsFieldType.Picklist));
newFields.Add("Field011", new CdsDataTypeWrapper("RawValue", CdsFieldType.Raw));
newFields.Add("Field012", new CdsDataTypeWrapper(testSupport._DefaultId, CdsFieldType.UniqueIdentifier));
Entity acctEntity = new Entity("account");
acctEntity.Attributes.Add("name", "CrudTestAccount");
acctEntity.Attributes.Add("Field01", false);
acctEntity.Attributes.Add("Field02", new EntityReference("parentaccount", testSupport._DefaultId));
acctEntity.Attributes.Add("Field03", DateTime.UtcNow);
acctEntity.Attributes.Add("Field04", 64);
acctEntity.Attributes.Add("Field05", 1.001);
acctEntity.Attributes.Add("Field08", 50);
acctEntity.Attributes.Add("Field09", 100);
acctEntity.Attributes.Add("Field010", new OptionSetValue(20));
// Test Helper create
var respId = cli.CreateNewRecord("account", newFields);
Assert.Equal(testSupport._DefaultId, respId);
// Test entity create
var response = cli.ExecuteCdsOrganizationRequest(new CreateRequest()
{
Target = acctEntity
}, useWebAPI: false);
Assert.NotNull(response);
respId = ((CreateResponse)response).id;
Assert.Equal(testSupport._DefaultId, respId);
// Test low level create
respId = cli.Create(acctEntity);
Assert.Equal(testSupport._DefaultId, respId);
}
public static CreateObjectOutput CreateObjectinTCAndReturnTCItemIdAndRev(CreateObjectParameters[] createObjectParList, String ItemTypeName, String ItemRevisionName)
{
String item_id = "";
String revision_id = "";
InitializeProces();
// The create input for the ChangeNotice Item
Teamcenter.Services.Strong.Core._2008_06.DataManagement.CreateInput itemCreateIn = new Teamcenter.Services.Strong.Core._2008_06.DataManagement.CreateInput();
itemCreateIn.BoName = ItemTypeName;
//itemCreateIn.BoName = "A9_AutoCN";
// The create input for the ChangeNoticeRevision
Teamcenter.Services.Strong.Core._2008_06.DataManagement.CreateInput revisionCreateIn = new Teamcenter.Services.Strong.Core._2008_06.DataManagement.CreateInput();
revisionCreateIn.BoName = ItemRevisionName;
//revisionCreateIn.BoName = "A9_AutoCNRevision";
foreach (CreateObjectParameters createObjectPar in createObjectParList)
{
String propType = createObjectPar.propType;
String propOn = createObjectPar.propOn;
switch (propType.ToLower())
{
case "string":
if (propOn == "Item")
{
itemCreateIn.StringProps.Add(createObjectPar.propName, createObjectPar.propValue);
}
else
{
revisionCreateIn.StringProps.Add(createObjectPar.propName, createObjectPar.propValue);
}
break;
case "date":
DateTime dateValue = Teamcenter.Soa.Client.Model.Property.ParseDate(createObjectPar.propValue);
if (propOn == "Item")
{
itemCreateIn.DateProps.Add(createObjectPar.propName, dateValue);
}
else
{
revisionCreateIn.DateProps.Add(createObjectPar.propName, dateValue);
}
break;
}
}
// Tie the Revision CreateInput to the Item CreateInput
itemCreateIn.CompoundCreateInput.Add("revision", new Teamcenter.Services.Strong.Core._2008_06.DataManagement.CreateInput[] { revisionCreateIn });
// The data for the createObjects call
Teamcenter.Services.Strong.Core._2008_06.DataManagement.CreateIn cnCreateIn = new Teamcenter.Services.Strong.Core._2008_06.DataManagement.CreateIn();
cnCreateIn.ClientId = "One";
cnCreateIn.Data = itemCreateIn;
CreateResponse createResponse = dmService.CreateObjects(new Teamcenter.Services.Strong.Core._2008_06.DataManagement.CreateIn[] { cnCreateIn });
if (createResponse.ServiceData.sizeOfPartialErrors() > 0)
{
//createResponse.ServiceData.;
}
else
{
//Teamcenter.Services.Strong.Core._2008_06.DataManagement.CreateOut[] createOut = createResponse.Output;
foreach (Teamcenter.Services.Strong.Core._2008_06.DataManagement.CreateOut createOut in createResponse.Output)
{
//createOut.ClientId
Console.WriteLine("Response for client ID " + createOut.ClientId);
foreach (ModelObject modelObject in createOut.Objects)
{
//modelObject.
//Console.WriteLine();
String[] uids = new String[1];
uids[0] = modelObject.Uid;
ServiceData sd = dmService.LoadObjects(uids);
ModelObject[] foundObjs = new ModelObject[sd.sizeOfPlainObjects()];
for (int k = 0; k < sd.sizeOfPlainObjects(); k++)
{
foundObjs[k] = sd.GetPlainObject(k);
if (foundObjs[k].SoaType.ClassName == ItemRevisionName)
{
dmService.GetProperties(foundObjs, new String[] { "item_id" });
item_id = foundObjs[k].GetPropertyDisplayableValue("item_id");
dmService.GetProperties(foundObjs, new String[] { "item_revision_id" });
revision_id = foundObjs[k].GetPropertyDisplayableValue("item_revision_id");
}
}
}
}
}
CreateObjectOutput createObjectOutput = new CreateObjectOutput(item_id, revision_id);
return(createObjectOutput);
}
/// <summary>
/// Create a user without or without a password and return a ClaimsIdentity representing the user created.
/// </summary>
/// <param name="request">Instance of CreateRequest</param>
/// <returns>Instance of CreateResponse</returns>
public async Task<CreateResponse> CreateAsync(CreateRequest request)
{
CreateResponse response = new CreateResponse();
try
{
AspNetUser newUser = new AspNetUser()
{
Id = Guid.NewGuid().ToString(),
FirstName = request.FirstName,
LastName = request.LastName,
UserName = request.UserName,
Discriminator = "ApplicationUser" //Change as per your requirements
};
IdentityResult result;
if (!string.IsNullOrWhiteSpace(request.Password))
result = await this.UserManager.CreateAsync(newUser, request.Password);
else
result = await this.UserManager.CreateAsync(newUser);
if (result.Succeeded)
{
string authType = EnumStringValue.GetStringValue(request.AuthenticationType);
ClaimsIdentity identity = await this.UserManager.CreateIdentityAsync(newUser, authType);
response.UserId = new Guid(newUser.Id);
response.ClaimIdentity = identity.ConvertToClaimIdentityView();
response.Success = true;
}
else
{
response.AddErrors(response.Errors);
response.Success = false;
}
}
catch (Exception e)
{
response.Success = false;
response.Errors.Add(e.Message);
}
return response;
}
