public void Put_HasNoId_ThrowsException()
{
// Given
var response = new OrganizationResponse { Item = new Organization { Name = "blah blah" } };
var request = new OrganizationRequest { Item = new Organization { Name = "blah blah" } };
_client.Setup(b => b.Put<OrganizationResponse>(It.IsAny<Uri>(), request, "application/json")).Returns(response);
var resource = new OrganizationResource(_client.Object);
// When, Then
Assert.Throws<ArgumentException>(() => resource.Put(request));
}
public void CommitModifiedObject()
{
int callCount = 0;
int exptectedCallCount = 1;
var organisationService = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService();
organisationService.ExecuteOrganizationRequest = (request) =>
{
callCount++;
var results = new OrganizationResponse();
return results;
};
var crmUnitOfWork = new CrmUnitOfWork(organisationService);
var contactRepository = new
Xrm.Infrastructure.DataAccess.Crm.Fakes.StubContactRepository(organisationService, crmUnitOfWork);
contactRepository.PersistUpdatedEntityBase = (contact) =>
{
var sdkContact = new Contact();
sdkContact.ContactId = contact.Id;
sdkContact.FirstName = "test";
var updateRequest = new UpdateRequest()
{
Target = sdkContact
};
crmUnitOfWork.Requests.Add(updateRequest);
};
contactRepository.Update(new Xrm.Domain.Contact.Contact());
crmUnitOfWork.Commit();
Assert.AreEqual(exptectedCallCount, callCount);
}
public EntityMetadataReader(OrganizationResponse response)
{
var metadataResponse = response as RetrieveAllEntitiesResponse;
if (metadataResponse == null)
throw new ArgumentException("NULL metadata response, no valid response from CRM");
_metadataResponse = metadataResponse;
}
/// <summary>
/// constructor for the wrapper
/// </summary>
/// <param name="response">accepts an object that derives from the OrganizationResponse class</param>
public RetrieveAttributeResponseWrapper(OrganizationResponse response)
{
try
{
_metadata = ((RetrieveAttributeResponseWrapper)response).AttributeMetadata;
}
catch
{
_metadata = ((RetrieveAttributeResponse)response).AttributeMetadata;
}
}
public void Get_Called_ReturnsResponse()
{
// Given
var response = new OrganizationResponse { Item = new Organization { Id = 1 } };
_client.Setup(b => b.Get<OrganizationResponse>(It.IsAny<Uri>())).Returns(response);
var resource = new OrganizationResource(_client.Object);
// When
var result = resource.Get(321);
// Then
Assert.That(result, Is.EqualTo(response));
}
public void Put_CalledWithItem_ReturnsReponse()
{
// Given
var response = new OrganizationResponse { Item = new Organization { Name = "blah blah" } };
var request = new OrganizationRequest { Item = new Organization { Name = "blah blah", Id = 123 } };
_client.Setup(b => b.Put<OrganizationResponse>(It.IsAny<Uri>(), request, "application/json")).Returns(response);
var resource = new OrganizationResource(_client.Object);
// When
var result = resource.Put(request);
// Then
Assert.That(result, Is.EqualTo(response));
}
public Result(bool _isError, string _Message, IDetailedLog _LogSystem, OrganizationResponse _Response)
{
Message = _Message;
isError = _isError;
Response = _Response;
LogSystem = _LogSystem;
if (Message != null && Message != string.Empty)
{
System.Diagnostics.EventLogEntryType logType = System.Diagnostics.EventLogEntryType.Information;
if (isError)
logType = System.Diagnostics.EventLogEntryType.Error;
if (LogSystem != null)
LogSystem.CreateLog(Message, logType);
}
}
public async void GetAsync_Called_ReturnsResponse()
{
// Given
var response = new OrganizationResponse { Item = new Organization { Id = 1 } };
_client.Setup(b => b.GetAsync<OrganizationResponse>(
It.IsAny<Uri>(),
It.IsAny<string>(),
It.IsAny<string>()))
.Returns(TaskHelper.CreateTaskFromResult(response));
var resource = new OrganizationResource(_client.Object);
// When
var result = await resource.GetAsync(321);
// Then
Assert.That(result, Is.EqualTo(response));
}
static ServiceTestCases()
{
expectedResultCreate = Guid.NewGuid();
expectedResultRetrieve = new Entity()
{
Id = Guid.NewGuid()
};
expectedResultRetrieveMultiple = new EntityCollection();
expectedResultRetrieveMultiple.Entities.Add(new Entity());
expectedResultRetrieveMultiple.Entities.Add(new Entity());
expectedResultRetrieveMultiple.Entities.Add(new Entity());
expectedResultRetrieveMultiple.Entities.Add(new Entity());
expectedResultRetrieveMultiple.Entities.Add(new Entity());
expectedResultExecute = new OrganizationResponse()
{
ResponseName = "Test"
};
}
public static OrganizationResponse MockOrDefault(this IOrganizationService s, OrganizationRequest request,
Func <OrganizationRequest, bool> useMock, OrganizationResponse response)
{
return(useMock(request) ? response : s.Execute(request));
}
private static EntityReference GetEntityReference(OrganizationRequest request, OrganizationResponse response)
{
switch (request.RequestName)
{
case "Create":
return(new EntityReference((request["Target"] as Entity).LogicalName, (Guid)response["id"]));
case "Update":
return((request["Target"] as Entity).ToEntityReference());
case "Delete":
return(request["Target"] as EntityReference);
case "SetState":
return(request["EntityMoniker"] as EntityReference);
}
return(null);
}
protected void AssignResponseParameter(CrmDbCommand command, OrganizationResponse response)
{
if (command != null && command.Parameters.Contains(SystemCommandParameters.OrgResponse) && command.Parameters[SystemCommandParameters.OrgResponse].Direction == ParameterDirection.Output)
{
command.Parameters[SystemCommandParameters.OrgResponse].Value = response;
}
}
public ActionResult OrgInfo(OrgAdminInfoModel OrgAdminInfoModel)
{
int UserId = SurveyHelper.GetDecryptUserId(Session["UserId"].ToString());
int UserHighestRole = int.Parse(Session["UserHighestRole"].ToString());
string url = "";
if (this.Request.UrlReferrer == null)
{
url = this.Request.Url.ToString();
}
else
{
url = this.Request.UrlReferrer.ToString();
}
//Edit Organization
if (OrgAdminInfoModel.IsEditMode)
{
ModelState.Remove("AdminFirstName");
ModelState.Remove("AdminLastName");
ModelState.Remove("ConfirmAdminEmail");
ModelState.Remove("AdminEmail");
OrganizationRequest Request = new OrganizationRequest();
UserDTO AdminInfo = new UserDTO();
AdminInfo.FirstName = "";
AdminInfo.LastName = "";
AdminInfo.EmailAddress = "";
AdminInfo.Role = 0;
AdminInfo.PhoneNumber = "";
Request.OrganizationAdminInfo = AdminInfo;
Request.Organization.Organization = OrgAdminInfoModel.OrgName;
Request.Organization.IsEnabled = OrgAdminInfoModel.IsOrgEnabled;
Request.Organization.OrganizationKey = GetOrgKey(url);
Request.UserId = UserId;
Request.UserRole = UserHighestRole;
Request.Action = "UpDate";
try
{
OrganizationResponse Result = _isurveyFacade.SetOrganization(Request);
OrganizationResponse Organizations = _isurveyFacade.GetUserOrganizations(Request);
List <OrganizationModel> Model = Mapper.ToOrganizationModelList(Organizations.OrganizationList);
OrgListModel OrgListModel = new OrgListModel();
OrgListModel.OrganizationList = Model;
OrgListModel.Message = "Organization " + OrgAdminInfoModel.OrgName + " has been updated.";
if (Result.Message.ToUpper() != "EXISTS" && Result.Message.ToUpper() != "ERROR")
{
OrgListModel.Message = "Organization " + OrgAdminInfoModel.OrgName + " has been updated.";
return(View("OrgList", OrgListModel));
}
else if (Result.Message.ToUpper() == "ERROR")
{
OrgAdminInfoModel OrgInfo = new OrgAdminInfoModel();
Request.Organization.OrganizationKey = GetOrgKey(url);;
Organizations = _isurveyFacade.GetOrganizationInfo(Request);
OrgInfo = Mapper.ToOrgAdminInfoModel(Organizations);
OrgInfo.IsEditMode = true;
ModelState.AddModelError("IsOrgEnabled", "Organization for the super admin cannot be deactivated.");
return(View("OrgInfo", OrgInfo));
}
else
{
OrgAdminInfoModel OrgInfo = new OrgAdminInfoModel();
Request.Organization.OrganizationKey = GetOrgKey(url);;
Organizations = _isurveyFacade.GetOrganizationInfo(Request);
OrgInfo = Mapper.ToOrgAdminInfoModel(Organizations);
OrgInfo.IsEditMode = true;
ModelState.AddModelError("OrgName", "The organization name provided already exists.");
return(View("OrgInfo", OrgInfo));
}
}
catch (Exception ex)
{
return(View(OrgAdminInfoModel));
}
}
else
{
// Add new Organization
if (ModelState.IsValid)
{
OrganizationRequest Request = new OrganizationRequest();
Request.Organization.Organization = OrgAdminInfoModel.OrgName;
Request.Organization.IsEnabled = OrgAdminInfoModel.IsOrgEnabled;
UserDTO AdminInfo = new UserDTO();
AdminInfo.FirstName = OrgAdminInfoModel.AdminFirstName;
AdminInfo.LastName = OrgAdminInfoModel.AdminLastName;
AdminInfo.EmailAddress = OrgAdminInfoModel.AdminEmail;
AdminInfo.Role = 2;
AdminInfo.PhoneNumber = "123456789";
AdminInfo.UGuid = Guid.NewGuid();
Request.OrganizationAdminInfo = AdminInfo;
Request.UserRole = UserHighestRole;
Request.UserId = UserId;
Request.Action = "Insert";
try
{
OrganizationResponse Result = _isurveyFacade.SetOrganization(Request);
OrgListModel OrgListModel = new OrgListModel();
OrganizationResponse Organizations = _isurveyFacade.GetUserOrganizations(Request);
List <OrganizationModel> Model = Mapper.ToOrganizationModelList(Organizations.OrganizationList);
OrgListModel.OrganizationList = Model;
if (Result.Message.ToUpper() != "EXISTS")
{
OrgListModel.Message = "Organization " + OrgAdminInfoModel.OrgName + " has been created.";
}
else
{
// OrgListModel.Message = "The organization name provided already exists.";
OrgAdminInfoModel OrgInfo = new OrgAdminInfoModel();
//Request.Organization.OrganizationKey = GetOrgKey(url); ;
//Organizations = _isurveyFacade.GetOrganizationInfo(Request);
OrgInfo = Mapper.ToOrgAdminInfoModel(Organizations);
OrgInfo.IsEditMode = false;
ModelState.AddModelError("OrgName", "The organization name provided already exists.");
return(View("OrgInfo", OrgInfo));
}
return(View("OrgList", OrgListModel));
}
catch (Exception ex)
{
return(View(OrgAdminInfoModel));
}
}
else
{
return(View(OrgAdminInfoModel));
}
}
}
private void LoadEntityDetailsCompleted(string entityName, OrganizationResponse Result, Exception Error)
{
if (Error != null)
{
entityShitList.Add(entityName);
MessageBox.Show(Error.Message, "Load attribute metadata", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
if (Result is RetrieveMetadataChangesResponse)
{
var resp = (RetrieveMetadataChangesResponse)Result;
if (resp.EntityMetadata.Count == 1)
{
if (entities.ContainsKey(entityName))
{
entities[entityName] = resp.EntityMetadata[0];
}
else
{
entities.Add(entityName, resp.EntityMetadata[0]);
}
}
else
{
entityShitList.Add(entityName);
MessageBox.Show("Metadata not found for entity " + entityName, "Load attribute metadata", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
working = false;
TreeNodeHelper.SetNodeText(tvFetch.SelectedNode, currentSettings.useFriendlyNames);
}
working = false;
}
public async void DeleteAsync_Called_CallsDeleteOnClient()
{
// Given
var response = new OrganizationResponse { Item = new Organization { Id = 1 } };
_client.Setup(b => b.GetAsync<OrganizationResponse>(
It.IsAny<Uri>(),
It.IsAny<string>(),
It.IsAny<string>()))
.Returns(TaskHelper.CreateTaskFromResult(response));
var resource = new OrganizationResource(_client.Object);
// When
await resource.DeleteAsync(321);
// Then
_client.Verify(c => c.DeleteAsync<object>(It.IsAny<Uri>(), It.IsAny<object>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()));
}
/// <summary>
/// Display the response of an organization message request.
/// </summary>
/// <param name="organizationRequest">The organization message request.</param>
/// <param name="organizationResponse">The organization message response.</param>
private void DisplayResponse(OrganizationRequest organizationRequest, OrganizationResponse organizationResponse)
{
Console.WriteLine("Returned entity " + ((Entity)organizationRequest.Parameters["Target"])["name"]
+ " with account id as " + organizationResponse.Results["id"].ToString());
// + " with " + organizationResponse.Results["id"].ToString());
// _newAccountIds.Add(new Guid(organizationResponse.Results["id"].ToString()));
}
public OrganizationResponse SetOrganization(OrganizationRequest request)
{
try
{
Epi.Web.BLL.Organization organizationImplementation = new Epi.Web.BLL.Organization(_organizationDao);
// Transform SurveyInfo data transfer object to SurveyInfo business object
var organization = request.Organization.ToOrganizationBO();
var user = request.OrganizationAdminInfo.ToUserBO();
var response = new OrganizationResponse();
if (request.Action.ToUpper() == "UPDATE")
{
if (!ValidRequest(request, response, Validate.All))
{
response.Message = "Error";
return(response);
}
if (organizationImplementation.OrganizationNameExists(organization.Organization, organization.OrganizationKey, "Update"))
{
response.Message = "Exists";
}
else
{
var success = organizationImplementation.UpdateOrganizationInfo(organization);
if (success)
{
response.Message = "Successfully added organization Key";
}
else
{
response.Message = "Error";
return(response);
}
}
}
else if (request.Action.ToUpper() == "INSERT")
{
Guid organizationKey = Guid.NewGuid();
organization.OrganizationKey = organizationKey.ToString();
if (!ValidRequest(request, response, Validate.All))
{
return(response);
}
if (organizationImplementation.OrganizationNameExists(organization.Organization, organization.OrganizationKey, "Create"))
{
response.Message = "Exists";
}
else
{
organizationImplementation.InsertOrganizationInfo(organization, user);
response.Message = "Success";
}
}
return(response);
}
catch (Exception ex)
{
throw new FaultException <CustomFaultException>(new CustomFaultException(ex));
}
}
public void CreateAccountTest()
{
//
// Arrange
//
var connection = new CrmConnection("Crm");
var service = new OrganizationService(connection);
var context = new OrganizationServiceContext(service);
using (ShimsContext.Create())
{
string accountName = "abcabcabc";
Guid actual;
Guid expected = Guid.NewGuid();
int callCount = 0;
Entity entity = null;
var fakeContext = new Microsoft.Xrm.Sdk.Client.Fakes.ShimOrganizationServiceContext(context);
fakeContext.AddObjectEntity = e =>
{
callCount++;
entity = e;
};
fakeContext.SaveChanges = () =>
{
entity.Id = expected;
// SaveChangesResultCollection only has one internal constructor
// so we can not create a instance outside of Microsoft.Xrm.Sdk assembly
// we will use reflection to create instances of SaveChangesResultCollection and SaveChangesResult
var results = CreateSaveChangesResultCollection(SaveChangesOptions.None);
var request = new OrganizationRequest();
var response = new OrganizationResponse();
results.Add(CreateSaveChangesResult(request, response));
return(results);
};
ContextMethods target = new ContextMethods(context);
//
// Act
//
actual = target.CreateAccount(accountName);
//
// Assert
//
Assert.AreEqual(callCount, 1); // verify OrganizationServiceContext.AddObject is called once
Assert.IsNotNull(entity); // verify OrganizationServiceContext.AddObject is called with not null object
Assert.AreEqual(entity.LogicalName, "account"); // verify OrganizationServiceContext.AddObject is called with entity with proper entity name
Assert.AreEqual(entity.GetAttributeValue <string>("name"), accountName); // verify OrganizationServiceContext.AddObject is called with entity with proper value set on name attribute
Assert.AreEqual(expected, actual);
}
}
public ActionResult OrgInfo(OrgAdminInfoModel orgAdminInfoModel)
{
int userId = GetIntSessionValue(UserSession.Key.UserId);
int userHighestRole = GetIntSessionValue(UserSession.Key.UserHighestRole);
string url = "";
if (this.Request.UrlReferrer == null)
{
url = this.Request.Url.ToString();
}
else
{
url = this.Request.UrlReferrer.ToString();
}
//Edit Organization
if (orgAdminInfoModel.IsEditMode)
{
ModelState.Remove("AdminFirstName");
ModelState.Remove("AdminLastName");
ModelState.Remove("ConfirmAdminEmail");
ModelState.Remove("AdminEmail");
OrganizationRequest request = new OrganizationRequest();
UserDTO adminInfo = new UserDTO();
adminInfo.FirstName = "";
adminInfo.LastName = "";
adminInfo.EmailAddress = "";
adminInfo.Role = 0;
adminInfo.PhoneNumber = "";
request.OrganizationAdminInfo = adminInfo;
request.Organization.Organization = orgAdminInfoModel.OrgName;
request.Organization.IsEnabled = orgAdminInfoModel.IsOrgEnabled;
request.Organization.IsHostOrganization = orgAdminInfoModel.IsHostOrganization;
request.Organization.OrganizationKey = GetOrgKey(url);
request.UserId = userId;
request.UserRole = userHighestRole;
request.Action = RequestAction.Update;
try
{
OrganizationResponse result = _securityFacade.SetOrganization(request);
OrganizationResponse organizations = _securityFacade.GetUserOrganizations(request);
List <OrganizationModel> model = organizations.OrganizationList.ToOrganizationModelList();
OrgListModel orgListModel = new OrgListModel();
orgListModel.OrganizationList = model;
orgListModel.Message = "Organization " + orgAdminInfoModel.OrgName + " has been updated.";
if (result.Message.ToUpper() != "EXISTS" && result.Message.ToUpper() != "ERROR")
{
orgListModel.Message = "Organization " + orgAdminInfoModel.OrgName + " has been updated.";
return(View(ViewActions.OrgList, orgListModel));
}
else if (result.Message.ToUpper() == "ERROR")
{
OrgAdminInfoModel orgInfo = new OrgAdminInfoModel();
request.Organization.OrganizationKey = GetOrgKey(url);;
organizations = _securityFacade.GetOrganizationInfo(request);
orgInfo = organizations.ToOrgAdminInfoModel();
orgInfo.IsEditMode = true;
ModelState.AddModelError("IsOrgEnabled", "Organization for the super admin cannot be deactivated.");
return(View(ViewActions.OrgInfo, orgInfo));
}
else
{
OrgAdminInfoModel orgInfo = new OrgAdminInfoModel();
request.Organization.OrganizationKey = GetOrgKey(url);;
organizations = _securityFacade.GetOrganizationInfo(request);
orgInfo = organizations.ToOrgAdminInfoModel();
orgInfo.IsEditMode = true;
ModelState.AddModelError("OrgName", "The organization name provided already exists.");
return(View(ViewActions.OrgInfo, orgInfo));
}
}
catch (Exception ex)
{
return(View(orgAdminInfoModel));
}
}
else
{
// Add new Organization
if (ModelState.IsValid)
{
OrganizationRequest request = new OrganizationRequest();
request.Organization.Organization = orgAdminInfoModel.OrgName;
request.Organization.IsEnabled = orgAdminInfoModel.IsOrgEnabled;
request.Organization.IsHostOrganization = orgAdminInfoModel.IsHostOrganization;
UserDTO adminInfo = new UserDTO();
adminInfo.FirstName = orgAdminInfoModel.AdminFirstName;
adminInfo.LastName = orgAdminInfoModel.AdminLastName;
adminInfo.EmailAddress = orgAdminInfoModel.AdminEmail;
adminInfo.Role = Roles.Administrator;
adminInfo.PhoneNumber = "123456789";
adminInfo.UGuid = Guid.NewGuid();
request.OrganizationAdminInfo = adminInfo;
request.UserRole = userHighestRole;
request.UserId = userId;
request.Action = RequestAction.Insert;
try
{
OrganizationResponse result = _securityFacade.SetOrganization(request);
OrgListModel orgListModel = new OrgListModel();
OrganizationResponse organizations = _securityFacade.GetUserOrganizations(request);
List <OrganizationModel> model = organizations.OrganizationList.ToOrganizationModelList();
orgListModel.OrganizationList = model;
if (result.Message.ToUpper() != "EXISTS")
{
orgListModel.Message = "Organization " + orgAdminInfoModel.OrgName + " has been created.";
}
else
{
// OrgListModel.Message = "The organization name provided already exists.";
OrgAdminInfoModel orgInfo = new OrgAdminInfoModel();
//Request.Organization.OrganizationKey = GetOrgKey(url); ;
//Organizations = _isurveyFacade.GetOrganizationInfo(Request);
orgInfo = organizations.ToOrgAdminInfoModel();
orgInfo.IsEditMode = false;
ModelState.AddModelError("OrgName", "The organization name provided already exists.");
return(View(ViewActions.OrgInfo, orgInfo));
}
return(View(ViewActions.OrgList, orgListModel));
}
catch (Exception ex)
{
return(View(orgAdminInfoModel));
}
}
else
{
return(View(orgAdminInfoModel));
}
}
}
internal static SonarQubeOrganization FromResponse(OrganizationResponse response)
{
return(new SonarQubeOrganization(response.Key, response.Name));
}
static void Main(string[] args)
{
do
{
CredentialsRepository userCredentials = new CredentialsRepository();
if (userCredentials.GetUsername() == string.Empty || userCredentials.GetPassword() == string.Empty)
{
Console.WriteLine("Enter your Username: "******"Enter your Password: "******"*");
}
else
{
if (key.Key == ConsoleKey.Backspace && password.Length > 0)
{
password.Substring(0, (password.Length - 1));
Console.Write("\b \b");
}
else if (key.Key == ConsoleKey.Enter)
{
break;
}
}
} while (true);
userCredentials.SavePassword(password);
Console.WriteLine();
}
string URL = string.Empty;
string path = Directory.GetParent(System.Reflection.Assembly.GetExecutingAssembly().Location).FullName;
string fileName = Path.Combine(path, "URL.txt");
if (File.Exists(fileName) && File.ReadAllText(fileName).Length != 0)
{
URL = File.ReadAllText(fileName);
}
else
{
Console.WriteLine("Enter your organization URL : ");
URL = Console.ReadLine();
File.WriteAllText(fileName, URL);
}
var credentials = new ClientCredentials();
credentials.UserName.UserName = userCredentials.GetUsername();
credentials.UserName.Password = userCredentials.GetPassword();
try
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
Uri OrganizationUri = new Uri(URL);
using (OrganizationServiceProxy serviceProxy = new OrganizationServiceProxy(OrganizationUri, null, credentials, null))
{
IOrganizationService service = (IOrganizationService)serviceProxy;
OrganizationRequest request = new OrganizationRequest("new_sales_info_retrieval");
OrganizationResponse response = service.Execute(request);
}
}
catch (Exception)
{
Console.WriteLine("Please Check connection, or try to enter your credentials again!");
userCredentials.ClearPassword();
userCredentials.ClearUsername();
File.WriteAllText(fileName, string.Empty);
continue;
}
break;
} while (true);
}
private SaveChangesResult CreateSaveChangesResult(OrganizationRequest request, OrganizationResponse response)
{
var con = typeof(SaveChangesResult).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault();
var result = con.Invoke(new object[] { request, response }) as SaveChangesResult;
return(result);
}
public CrmOperationResult(OrganizationResponse response, ResultSet resultSet, bool useResultCountAsReturnValue)
{
this.Response = response;
this.ResultSet = resultSet;
UseResultCountAsReturnValue = useResultCountAsReturnValue;
}
private ExecuteMultipleResponse ExecuteInternal(ExecuteMultipleRequest request)
{
var settings = request.Settings;
var response = new ExecuteMultipleResponse();
response.Results["Responses"] = new ExecuteMultipleResponseItemCollection();
for (int i = 0; i < request.Requests.Count; i++)
{
var childRequest = request.Requests[i];
OrganizationServiceFault fault = null;
OrganizationResponse childResponse = null;
try
{
if (childRequest.RequestName == "ExecuteMultiple")
{
throw new Exception("ExecuteMultipleRequest cannot contain an ExecuteMultipleRequest");
}
childResponse = ExecuteInternal((dynamic)childRequest);
if (!settings.ReturnResponses)
{
childResponse = null;
}
}
catch (NotImplementedException)
{
throw;
}
catch (FaultException <OrganizationServiceFault> ex)
{
response["IsFaulted"] = true;
fault = ex.Detail;
fault.ErrorDetails["CallStack"] = ex.StackTrace;
if (!settings.ContinueOnError)
{
break;
}
}
catch (Exception ex)
{
response["IsFaulted"] = true;
fault = new OrganizationServiceFault {
Message = ex.Message, Timestamp = DateTime.UtcNow
};
fault.ErrorDetails["CallStack"] = ex.StackTrace;
if (!settings.ContinueOnError)
{
break;
}
}
finally
{
if (childResponse != null || fault != null)
{
response.Responses.Add(new ExecuteMultipleResponseItem
{
Fault = fault,
RequestIndex = i,
Response = childResponse
});
}
}
}
return(response);
}
/// <inheritdoc />
public IReturnsResult <IOrganizationService> SetupExecute <TRequest>(Expression <Func <TRequest, bool> > match, OrganizationResponse returnResponse)
where TRequest : OrganizationRequest
{
return(this.Setup(service => service.Execute(It.Is <TRequest>(match))).Returns(returnResponse));
}
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);
}
public async void PostAsync_CalledWithItem_ReturnsReponse()
{
// Given
var response = new OrganizationResponse { Item = new Organization { Name = "blah blah" } };
var request = new OrganizationRequest { Item = new Organization { Name = "blah blah" } };
_client.Setup(b => b.PostAsync<OrganizationResponse>(
It.IsAny<Uri>(),
request,
"application/json",
It.IsAny<string>(),
It.IsAny<string>()))
.Returns(TaskHelper.CreateTaskFromResult(response));
var resource = new OrganizationResource(_client.Object);
// When
var result = await resource.PostAsync(request);
// Then
Assert.That(result, Is.EqualTo(response));
}
public CuteExecute(OrganizationRequest request, OrganizationResponse response)
: base(MessageName.Execute, new object[] { request }, response)
{
}
public void CommitRemovedObject()
{
int callCount = 0;
int exptectedCallCount = 1;
var organisationService = new Microsoft.Xrm.Sdk.Fakes.StubIOrganizationService();
organisationService.ExecuteOrganizationRequest = (request) =>
{
callCount++;
var results = new OrganizationResponse();
return results;
};
var crmUnitOfWork = new CrmUnitOfWork(organisationService);
var contactRepository = new
Xrm.Infrastructure.DataAccess.Crm.Fakes.StubContactRepository(organisationService, crmUnitOfWork);
contactRepository.PersistRemovedEntityBase = (contact) =>
{
var deleteRequest = new DeleteRequest()
{
Target = new EntityReference(Contact.EntityLogicalName, Guid.NewGuid())
};
crmUnitOfWork.Requests.Add(deleteRequest);
};
contactRepository.Remove(new Xrm.Domain.Contact.Contact());
crmUnitOfWork.Commit();
Assert.AreEqual(exptectedCallCount, callCount);
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var orgService = ctx.GetOrganizationService();
// Checking parameters
Guid processId = (Guid)request.Parameters[ParameterProcessId]; // Workflow Id
if (processId == null)
{
throw new Exception(ParameterProcessId + " is a required parameter.");
}
Guid newActiveStageId = (Guid)request.Parameters[ParameterNewActiveStageId];
if (newActiveStageId == null)
{
throw new Exception(ParameterNewActiveStageId + " is a required parameter.");
}
string currentEntityLogicalName = (string)request.Parameters[ParameterCurrentEntityLogicalName];
if (currentEntityLogicalName == null)
{
throw new Exception(ParameterCurrentEntityLogicalName + " is a required parameter.");
}
Guid currentEntityId = (Guid)request.Parameters[ParameterCurrentEntityId];
if (currentEntityId == null)
{
throw new Exception(ParameterCurrentEntityId + " is a required parameter.");
}
string nextEntityLogicalName = (string)request.Parameters[ParameterNextEntityLogicalName];
if (nextEntityLogicalName == null)
{
throw new Exception(ParameterNextEntityLogicalName + " is a required parameter.");
}
Guid nextEntityId = (Guid)request.Parameters[ParameterNextEntityId];
if (nextEntityId == null)
{
throw new Exception(ParameterNextEntityId + " is a required parameter.");
}
string traversedPath = (string)request.Parameters[ParameterNewTraversedPath];
// Actual request logic
// All current Entities (should be only one)
var currentEntities = (from c in ctx.CreateQuery(currentEntityLogicalName)
where c.Id == currentEntityId
select c);
if (!currentEntities.Any() && currentEntities.Count() != 1)
{
throw new Exception(string.Format("There are no or more than one {0} with Id {1}", currentEntityLogicalName, currentEntityId));
}
// Current Entity
var currentEntity = currentEntities.First();
currentEntity["stageid"] = newActiveStageId;
currentEntity["processid"] = processId;
currentEntity["traversedpath"] = traversedPath;
orgService.Update(currentEntity);
// All next Entities (should be only one)
var nextEntities = (from n in ctx.CreateQuery(nextEntityLogicalName)
where n.Id == nextEntityId
select n);
if (!nextEntities.Any() && nextEntities.Count() != 1)
{
throw new Exception(string.Format("There are no or more than one {0} with Id {1}", nextEntityLogicalName, nextEntityId));
}
// Next Entity
var nextEntity = nextEntities.First();
nextEntity["stageid"] = newActiveStageId;
nextEntity["processid"] = processId;
nextEntity["traversedpath"] = traversedPath;
orgService.Update(nextEntity);
// Response
var response = new OrganizationResponse()
{
// Response name should be equal with Request name to check if the response is corrent.
ResponseName = RequestName,
Results = new ParameterCollection()
};
// Add TraversedPath parameter
response.Results[ParameterTraversedPath] = traversedPath;
return(response);
}
private static T Return <T>(this OrganizationResponse response, string key)
{
return(response.Results.Contains(key) ? (T)response[key] : default(T));
}
public ExecuteResponse(OrganizationResponse response)
{
this.Response = response;
}
/// <summary>
/// Display the response of an organization message request.
/// </summary>
/// <param name="organizationRequest">The organization message request.</param>
/// <param name="organizationResponse">The organization message response.</param>
private void DisplayResponse(OrganizationRequest organizationRequest, OrganizationResponse organizationResponse)
{
Console.WriteLine("Created " + ((Account)organizationRequest.Parameters["Target"]).Name
+ " with account id as " + organizationResponse.Results["id"].ToString());
_newAccountIds.Add(new Guid(organizationResponse.Results["id"].ToString()));
}
public OrganizationResponse Execute(OrganizationRequest request)
{
OrganizationResponse response = CrmContext.OrganizationProxy.Execute(request);
return(response);
}
internal static OrganizationServiceCachePluginMessage GetMessage(OrganizationRequest request, OrganizationResponse response)
{
var reference = GetEntityReference(request, response);
if (reference != null)
{
return(new OrganizationServiceCachePluginMessage {
MessageName = request.RequestName, Target = reference.ToPluginMessageEntityReference()
});
}
if (request.RequestName == "Associate" || request.RequestName == "Disassociate")
{
var target = request["Target"] as EntityReference;
var relationship = request["Relationship"] as Relationship;
var relatedEntities = request["RelatedEntities"] as EntityReferenceCollection;
return(new OrganizationServiceCachePluginMessage
{
MessageName = request.RequestName,
Target = target.ToPluginMessageEntityReference(),
Relationship = relationship.ToPluginMessageRelationship(),
RelatedEntities = relatedEntities.ToPluginMessageEntityReferenceCollection(),
});
}
return(null);
}
public OrganizationResponse GetResponse <T>() where T : OrganizationResponse, new()
{
return(_response ?? (_response = new T {
Results = PluginExecutionContext.OutputParameters
}));
}
private void PublishComponents()
{
ExecuteAction("", "Publish", delegate
{
WriteProgress(new ProgressRecord(1, "Publishing Components", "Initializing components to publish...")
{
RecordType = ProgressRecordType.Processing
});
List <PublishComponentInfo> solutioncomponents = new List <PublishComponentInfo>();
if (Entities != null && Entities.Length > 0)
{
solutioncomponents.AddRange(Entities.Select(e => new PublishComponentInfo()
{
ComponentType = 1,
LogicalName = e
}));
}
if (Optionsets != null && Optionsets.Length > 0)
{
solutioncomponents.AddRange(Optionsets.Select(e => new PublishComponentInfo()
{
ComponentType = 9,
LogicalName = e
}));
}
if (Dashboards != null && Dashboards.Length > 0)
{
solutioncomponents.AddRange(Dashboards.Select(e => new PublishComponentInfo()
{
ComponentType = 60,
ObjectId = e
}));
}
if (Webresources != null && Webresources.Length > 0)
{
solutioncomponents.AddRange(Webresources.Select(e => new PublishComponentInfo()
{
ComponentType = 61,
ObjectId = e
}));
}
string publishXml = ConstructPublishXml(solutioncomponents, PublishRibbon.ToBool(), PublishSiteMap.ToBool());
base.WriteVerboseWithTimestamp(publishXml);
WriteProgress(new ProgressRecord(1, "Publishing Components", "Publishing selected components...")
{
RecordType = ProgressRecordType.Processing
});
OrganizationRequest request = new OrganizationRequest("PublishXml")
{
Parameters = new ParameterCollection()
};
request.Parameters.Add("ParameterXml", publishXml);
OrganizationResponse response = _repository.Execute(request);
});
}
private static EntityReference BusinessLogic(CodeActivityContext executionContext, EntityReference lead)
{
ITracingService tracingService = executionContext.GetExtension <ITracingService>();
var returnedReference = new EntityReference();
try
{
//Create the context
IWorkflowContext context = executionContext.GetExtension <IWorkflowContext>();
IOrganizationServiceFactory serviceFactory =
executionContext.GetExtension <IOrganizationServiceFactory>();
IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
#region License Validation
OrganizationRequest Req = new OrganizationRequest("hdn_ValidateLicense");
Req["ProductName"] = "BareBonesSalesCore"; //pass in the Solution Name
OrganizationResponse Response = service.Execute(Req);
if (Response.Results.ContainsKey("IsValid") && Response.Results["IsValid"].ToString() != "True")
{
var errorText = "The license for Bare Bones Sales Core is invalid. ";
if (Response.Results.Contains("ErrorMessage"))
{
errorText = errorText + Response.Results["ErrorMessage"];
}
throw new InvalidPluginExecutionException(errorText);
}
#endregion
// pull the input parameters
var leadDetails = service.Retrieve(lead.LogicalName, lead.Id, new ColumnSet("hdn_email", "hdn_lastname", "hdn_website", "hdn_company", "hdn_topic", "hdn_description"));
if (leadDetails != null)
{
var contactId = new EntityReference("contact");
if (leadDetails.Contains("hdn_email"))
{
var query2 = new QueryExpression("contact");
query2.ColumnSet = new ColumnSet("emailaddress1");
query2.Criteria.AddFilter(LogicalOperator.And);
query2.Criteria.AddCondition("emailaddress1", ConditionOperator.Equal, leadDetails.GetAttributeValue <string>("hdn_email"));
var contacts = service.RetrieveMultiple(query2);
if (contacts.Entities.Count > 0)
{
contactId.Id = contacts.Entities[0].Id;
}
}
if (contactId.Id == new Guid())
{
tracingService.Trace("creating lead");
if (leadDetails.Contains("hdn_lastname"))
{
var initialize = new InitializeFromRequest();
initialize.TargetEntityName = "contact";
initialize.EntityMoniker = lead;
// Execute the request
var initialized =
(InitializeFromResponse)service.Execute(initialize);
if (initialized.Entity != null &&
initialized.Entity.LogicalName == "contact")
{
;
}
var contact = initialized.Entity;
var contactGuid = service.Create(contact);
contactId.Id = contactGuid;
}
}
var accountId = new EntityReference("account");
if (leadDetails.Contains("hdn_website"))
{
var query3 = new QueryExpression("account");
query3.ColumnSet = new ColumnSet("websiteurl");
query3.Criteria.AddFilter(LogicalOperator.And);
query3.Criteria.AddCondition("websiteurl", ConditionOperator.Equal, leadDetails.GetAttributeValue <string>("hdn_website"));
var accounts = service.RetrieveMultiple(query3);
if (accounts.Entities.Count > 0)
{
accountId.Id = accounts.Entities[0].Id;
}
}
if (accountId.Id == Guid.Empty)
{
if (leadDetails.Contains("hdn_company"))
{
var initializeAccount = new InitializeFromRequest();
initializeAccount.TargetEntityName = "account";
initializeAccount.EntityMoniker = lead;
// Execute the request
var initializedAccount =
(InitializeFromResponse)service.Execute(initializeAccount);
if (initializedAccount.Entity != null &&
initializedAccount.Entity.LogicalName == "account")
{
;
}
var account = initializedAccount.Entity;
if (contactId.Id != Guid.Empty)
{
account["primarycontactid"] = contactId;
}
var accountGuid = service.Create(account);
accountId.Id = accountGuid;
}
}
var initializeOpp = new InitializeFromRequest();
initializeOpp.TargetEntityName = "hdn_opportunity";
initializeOpp.EntityMoniker = lead;
// Execute the request
var initializedOpp =
(InitializeFromResponse)service.Execute(initializeOpp);
if (initializedOpp.Entity != null &&
initializedOpp.Entity.LogicalName == "hdn_opportunity")
{
var newEntity = initializedOpp.Entity;
if (accountId.Id != Guid.Empty)
{
newEntity.Attributes["hdn_customer"] = accountId;
}
else
{
if (contactId.Id != Guid.Empty)
{
newEntity.Attributes["hdn_customer"] = contactId;
}
}
if (contactId.Id != Guid.Empty)
{
newEntity.Attributes["hdn_contact"] = contactId;
}
//newEntity.Attributes["hdn_topic"] = leadDetails.GetAttributeValue<string>("hdn_topic");
var guid = service.Create(newEntity);
//finally with the opportunity created lets qualify the lead
var updateLead = new Entity(lead.LogicalName, lead.Id);
updateLead.Attributes.Add("statuscode", new OptionSetValue(752240000));
updateLead.Attributes.Add("statecode", new OptionSetValue(1));
service.Update(updateLead);
return(new EntityReference("hdn_opportunity", guid));
}
}
}
catch (InvalidPluginExecutionException ex)
{
throw;
}
catch (Exception ex)
{
tracingService.Trace(ex.Message);
tracingService.Trace(ex.StackTrace);
throw;
}
return(returnedReference);
}
internal OrganizationResponse Execute(OrganizationRequest request, EntityReference userRef, PluginContext parentPluginContext)
{
// Setup
dataMethods.HandleInternalPreOperations(request, userRef);
var primaryRef = Mappings.GetPrimaryEntityReferenceFromRequest(request);
// Create the plugin context
var pluginContext = new PluginContext()
{
UserId = userRef.Id,
InitiatingUserId = userRef.Id,
MessageName = RequestNameToMessageName(request.RequestName),
Depth = 1,
OrganizationName = dataMethods.OrganizationName,
OrganizationId = dataMethods.OrganizationId,
PrimaryEntityName = primaryRef?.LogicalName,
};
if (primaryRef != null)
{
pluginContext.PrimaryEntityId = dataMethods.GetEntityId(primaryRef).GetValueOrDefault();
}
foreach (var prop in request.Parameters)
{
pluginContext.InputParameters[prop.Key] = prop.Value;
}
if (parentPluginContext != null)
{
pluginContext.ParentContext = parentPluginContext;
pluginContext.Depth = parentPluginContext.Depth + 1;
}
var buRef = GetBusinessUnit(userRef);
Console.WriteLine($"User GUID: {userRef.Id}");
Console.WriteLine($"BU GUID: {buRef.Id}");
pluginContext.BusinessUnitId = buRef.Id;
Mappings.RequestToEventOperation.TryGetValue(request.GetType(), out EventOperation? eventOp);
var entityInfo = GetEntityInfo(request);
Entity preImage = null;
Entity postImage = null;
var settings = MockupExecutionContext.GetSettings(request);
// Validation
if (!settings.SetUnsettableFields && (request is UpdateRequest || request is CreateRequest))
{
var entity = request is UpdateRequest ? (request as UpdateRequest).Target : (request as CreateRequest).Target;
dataMethods.RemoveUnsettableAttributes(request.RequestName, entity);
}
// Pre operation
if (settings.TriggerProcesses && entityInfo != null)
{
preImage = TryRetrieve(primaryRef);
if (preImage != null)
{
primaryRef.Id = preImage.Id;
}
if (eventOp.HasValue)
{
pluginManager.Trigger(eventOp.Value, ExecutionStage.PreOperation, entityInfo.Item1, preImage, postImage, pluginContext, this);
workflowManager.Trigger(eventOp.Value, ExecutionStage.PreOperation, entityInfo.Item1, preImage, postImage, pluginContext, this);
}
}
// Core operation
OrganizationResponse response = ExecuteRequest(request, userRef, parentPluginContext);
// Post operation
if (settings.TriggerProcesses && entityInfo != null)
{
postImage = TryRetrieve(primaryRef);
if (eventOp.HasValue)
{
pluginManager.Trigger(eventOp.Value, ExecutionStage.PostOperation, entityInfo.Item1, preImage, postImage, pluginContext, this);
workflowManager.Trigger(eventOp.Value, ExecutionStage.PostOperation, entityInfo.Item1, preImage, postImage, pluginContext, this);
}
workflowManager.ExecuteWaitingWorkflows(pluginContext, this);
}
return(response);
}
private SonarQubeOrganization ToOrganization(OrganizationResponse response) => new SonarQubeOrganization(response.Key, response.Name);
/// <inheritdoc />
public IReturnsResult <IOrganizationService> SetupExecute <TRequest>(OrganizationResponse returnResponse)
where TRequest : OrganizationRequest
{
return(this.Setup(service => service.Execute(It.Is <OrganizationRequest>(x => x is TRequest))).Returns(returnResponse));
}
/// <summary>
/// Processes the non-global option sets
/// </summary>
/// <param name="dictionary">The <C>Dictionary</C> that contains the name value pairs for the option set.</param>
/// <param name="entityName">The name of the <C>Entity</C> that the option set belongs to.</param>
private void ProcessPickLists(Dictionary <string, object> dictionary, string entityName)
{
if (dictionary == null)
{
return;
}
OrganizationResponse langRes = null;
foreach (string attributeName in dictionary.Keys)
{
string[] values = dictionary[attributeName] as string[];
if (values.Length < 1)
{
continue;
}
RetrieveAttributeRequest attribReq = new RetrieveAttributeRequest();
attribReq.EntityLogicalName = entityName;
attribReq.LogicalName = attributeName;
attribReq.RetrieveAsIfPublished = true;
OrganizationRequest langReq = new OrganizationRequest("RetrieveAvailableLanguages");
// Get the attribute metadata for the state attribute.
RetrieveAttributeResponse metadataRespone = null;
try
{
metadataRespone = (RetrieveAttributeResponse)this.CrmAdapter.OrganizationService.Execute(attribReq);
if (langRes == null)
{
langRes = this.CrmAdapter.OrganizationService.Execute(langReq);
}
}
catch (Exception e)
{
throw new AdapterException(string.Format(CultureInfo.CurrentCulture, Resources.MetadataClientPicklistExceptionMessage, entityName, e.Message), e)
{
ExceptionId = ErrorCodes.PicklistMetadataRetrieval
};
}
if (metadataRespone != null)
{
PicklistAttributeMetadata picklistAttrib = metadataRespone.AttributeMetadata as PicklistAttributeMetadata;
int optionNumber = 200000;
InsertOptionValueRequest insertRequest = new InsertOptionValueRequest();
insertRequest.AttributeLogicalName = picklistAttrib.LogicalName;
insertRequest.EntityLogicalName = entityName;
insertRequest.Label = new Label();
insertRequest.Value = new int?();
foreach (string picklistName in values)
{
try
{
var option = picklistAttrib.OptionSet.Options.FirstOrDefault(opt => opt.Label.UserLocalizedLabel.Label.Replace(NotInErp, string.Empty).Trim().ToUpperInvariant() == picklistName.ToUpperInvariant() || opt.Label.UserLocalizedLabel.Label.Replace("*", string.Empty).Trim().ToUpperInvariant() == picklistName.ToUpperInvariant());
optionNumber += picklistAttrib.OptionSet.Options.Count();
// Add new values
if (option == null)
{
insertRequest.Value = optionNumber++;
insertRequest.Label = CreateSingleLabel(picklistName, metadataRespone.AttributeMetadata.DisplayName.UserLocalizedLabel.LanguageCode);
this.CrmAdapter.OrganizationService.Execute(insertRequest);
}
else if (option.Label.UserLocalizedLabel.Label != picklistName)
{
// Update existing values if they are different
this.CrmAdapter.OrganizationService.Execute(new UpdateOptionValueRequest()
{
AttributeLogicalName = picklistAttrib.LogicalName, EntityLogicalName = entityName, Label = CreateSingleLabel(picklistName, option.Label.UserLocalizedLabel.LanguageCode), MergeLabels = false, Value = option.Value.Value
});
}
}
catch (FaultException e)
{
if (e.Message.Contains("because another picklist or status option for this attribute already exists"))
{
throw new AdapterException(string.Format(CultureInfo.CurrentCulture, Resources.ValueExistsMessage, entityName, e.Message), e)
{
ExceptionId = ErrorCodes.PicklistMetadataCreation
};
}
else
{
throw new AdapterException(string.Format(CultureInfo.CurrentCulture, Resources.AddingValueExceptionMessage, picklistName, e.Message), e)
{
ExceptionId = ErrorCodes.PicklistMetadataCreation
};
}
}
}
}
}
}
public string ExportSolution(
string outputFolder,
SolutionExportOptions options)
{
Logger.LogVerbose("Exporting Solution: {0}", options.SolutionName);
var solutionFile = new StringBuilder();
Solution solution = GetSolution(options.SolutionName,
new ColumnSet("version"));
if (solution is null)
{
throw new Exception($"Unable to find solution with unique name: {options.SolutionName}");
}
else
{
Logger.LogInformation($"Exporting Solution: {options.SolutionName}, version: {solution.Version}");
}
solutionFile.Append(options.SolutionName);
if (options.IncludeVersionInName)
{
solutionFile.Append("_");
solutionFile.Append(solution.Version.Replace(".", "_"));
}
if (options.Managed)
{
solutionFile.Append("_managed");
}
solutionFile.Append(".zip");
var exportSolutionRequest = new ExportSolutionRequest
{
Managed = options.Managed,
SolutionName = options.SolutionName,
ExportAutoNumberingSettings = options.ExportAutoNumberingSettings,
ExportCalendarSettings = options.ExportCalendarSettings,
ExportCustomizationSettings = options.ExportCustomizationSettings,
ExportEmailTrackingSettings = options.ExportEmailTrackingSettings,
ExportGeneralSettings = options.ExportGeneralSettings,
ExportIsvConfig = options.ExportIsvConfig,
ExportMarketingSettings = options.ExportMarketingSettings,
ExportOutlookSynchronizationSettings = options.ExportOutlookSynchronizationSettings,
ExportRelationshipRoles = options.ExportRelationshipRoles,
ExportSales = options.ExportSales,
TargetVersion = options.TargetVersion,
RequestId = Guid.NewGuid()
};
Logger.LogVerbose($"RequestId: {exportSolutionRequest.RequestId}");
//keep seperate to allow compatibility with crm2015
if (options.ExportExternalApplications)
{
exportSolutionRequest.ExportExternalApplications = options.ExportExternalApplications;
}
byte[] solutionBytes;
if (options.ExportAsync)
{
Logger.LogInformation("Exporting Solution using Async Mode");
exportSolutionRequest.RequestName = "ExportSolutionAsync";
var asyncExportResponse = OrganizationService.Execute(exportSolutionRequest);
//Guid asyncJobId = asyncResponse.AsyncJobId;
Guid asyncJobId = (Guid)asyncExportResponse.Results["AsyncOperationId"];
Guid exportJobId = (Guid)asyncExportResponse.Results["ExportJobId"];
Logger.LogInformation($"AsyncOperationId: {asyncJobId}");
Logger.LogInformation($"ExportJobId: {exportJobId}");
AsyncOperationManager asyncOperationManager = new AsyncOperationManager(Logger, OrganizationService);
AsyncOperation operation = asyncOperationManager.AwaitCompletion(asyncJobId, options.AsyncWaitTimeout, options.SleepInterval, null);
Logger.LogInformation("Async Operation completed with status: {0}",
((AsyncOperation_StatusCode)operation.StatusCode.Value).ToString());
Logger.LogInformation("Async Operation completed with message: {0}",
operation.Message);
if (operation.StatusCode.Value == (int)AsyncOperation_StatusCode.Succeeded)
{
OrganizationRequest downloadReq = new OrganizationRequest("DownloadSolutionExportData");
downloadReq.Parameters.Add("ExportJobId", exportJobId);
OrganizationResponse downloadRes = OrganizationService.Execute(downloadReq);
solutionBytes = (byte[])downloadRes.Results["ExportSolutionFile"];
}
else
{
throw new Exception($"Export of solution '{options.SolutionName}' failed: {operation.Message}");
}
}
else
{
Logger.LogInformation("Exporting Solution using Sync Mode");
var exportSolutionResponse = OrganizationService.Execute(exportSolutionRequest) as ExportSolutionResponse;
solutionBytes = exportSolutionResponse.ExportSolutionFile;
}
string solutionFilePath = Path.Combine(outputFolder, solutionFile.ToString());
File.WriteAllBytes(solutionFilePath, solutionBytes);
Logger.LogInformation($"Solution Exported to: {solutionFilePath}");
Logger.LogInformation("Solution Zip Size: {0}", FileUtilities.GetFileSize(solutionFilePath));
return(solutionFilePath);
}
public TSOverviewPage(DateTime date, OrganizationResponse organization)
{
InitializeComponent();
BindingContext = new TSOverviewViewModel(date, organization);
}
public void PutAsync_HasNoId_ThrowsException()
{
// Given
var response = new OrganizationResponse { Item = new Organization { Name = "blah blah" } };
var request = new OrganizationRequest { Item = new Organization { Name = "blah blah" } };
_client.Setup(b => b.PutAsync<OrganizationResponse>(
It.IsAny<Uri>(),
request,
"application/json",
It.IsAny<string>(),
It.IsAny<string>()))
.Returns(TaskHelper.CreateTaskFromResult(response));
var resource = new OrganizationResource(_client.Object);
// When, Then
Assert.Throws<ArgumentException>(async () => await resource.PutAsync(request));
}
/// <summary>
/// Display the response of an organization message request.
/// </summary>
/// <param name="organizationRequest">The organization message request.</param>
/// <param name="organizationResponse">The organization message response.</param>
private static void DisplayResponse(OrganizationRequest organizationRequest, OrganizationResponse organizationResponse)
{
Console.WriteLine("Created " + ((Account)organizationRequest.Parameters["Target"]).Name
+ " with account id as " + organizationResponse.Results["id"].ToString());
_newAccountIds.Add(new Guid(organizationResponse.Results["id"].ToString()));
}
public void Delete_Called_CallsDeleteOnClient()
{
// Given
var response = new OrganizationResponse { Item = new Organization { Id = 1 } };
_client.Setup(b => b.Get<OrganizationResponse>(
It.IsAny<Uri>(),
It.IsAny<string>(),
It.IsAny<string>())).Returns(response);
var resource = new OrganizationResource(_client.Object);
// When
resource.Delete(321);
// Then
_client.Verify(c => c.Delete<object>(It.IsAny<Uri>(), It.IsAny<object>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()));
}
private ActionResult ValidateUser(UserLoginModel Model, string ReturnUrl)
{
string formId = "", pageNumber;
if (ReturnUrl == null || !ReturnUrl.Contains("/"))
{
ReturnUrl = "/Home/Index";
}
else
{
formId = ReturnUrl.Substring(0, ReturnUrl.IndexOf('/'));
pageNumber = ReturnUrl.Substring(ReturnUrl.LastIndexOf('/') + 1);
}
try
{
Epi.Cloud.Common.Message.UserAuthenticationResponse result = _securityFacade.ValidateUser(Model.UserName, Model.Password);
if (result.UserIsValid)
{
if (result.User.ResetPassword)
{
UserResetPasswordModel model = new UserResetPasswordModel();
model.UserName = Model.UserName;
model.FirstName = result.User.FirstName;
model.LastName = result.User.LastName;
ReadPasswordPolicy(model);
return(ResetPassword(model));
}
else
{
OrganizationRequest request = new OrganizationRequest();
request.UserId = result.User.UserId;
request.UserRole = result.User.UserHighestRole;
// OrganizationResponse organizations = _securityFacade.GetAdminOrganizations(request);
OrganizationResponse organizations = _securityFacade.GetUserOrganizations(request);
FormsAuthentication.SetAuthCookie(Model.UserName, false);
SetSessionValue(UserSession.Key.UserId, result.User.UserId);
//SetSessionValue(UserSession.Key.UsertRole, result.User.Role);
SetSessionValue(UserSession.Key.UserHighestRole, result.User.UserHighestRole);
SetSessionValue(UserSession.Key.UserEmailAddress, result.User.EmailAddress);
SetSessionValue(UserSession.Key.UserFirstName, result.User.FirstName);
SetSessionValue(UserSession.Key.UserLastName, result.User.LastName);
SetSessionValue(UserSession.Key.UserName, result.User.UserName);
SetSessionValue(UserSession.Key.UGuid, result.User.UGuid);
SetSessionValue(UserSession.Key.CurrentOrgId, organizations.OrganizationList[0].OrganizationId);
return(RedirectToAction(ViewActions.Index, ControllerNames.Home, new { surveyid = formId }));
//return Redirect(ReturnUrl);
}
}
//else
{
ModelState.AddModelError("", "The email or password you entered is incorrect.");
Model.ViewValidationSummary = true;
return(View(Model));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", "The email or password you entered is incorrect.");
Model.ViewValidationSummary = true;
return(View(Model));
throw;
}
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var executeMultipleRequest = (ExecuteMultipleRequest)request;
if (executeMultipleRequest.Settings == null)
{
throw new FaultException <OrganizationServiceFault>(new OrganizationServiceFault(), "You need to pass a value for 'Settings' in execute multiple request");
}
if (executeMultipleRequest.Requests == null)
{
throw new FaultException <OrganizationServiceFault>(new OrganizationServiceFault(), "You need to pass a value for 'Requests' in execute multiple request");
}
var service = ctx.GetFakedOrganizationService();
var response = new ExecuteMultipleResponse();
response.Results["Responses"] = new ExecuteMultipleResponseItemCollection();
for (var i = 0; i < executeMultipleRequest.Requests.Count; i++)
{
var executeRequest = executeMultipleRequest.Requests[i];
try
{
OrganizationResponse resp = service.Execute(executeRequest);
if (executeMultipleRequest.Settings.ReturnResponses)
{
response.Responses.Add(new ExecuteMultipleResponseItem
{
RequestIndex = i,
Response = resp
});
}
}
catch (Exception ex)
{
if (!response.IsFaulted)
{
response.Results["IsFaulted"] = true;
}
response.Responses.Add(new ExecuteMultipleResponseItem
{
Fault = new OrganizationServiceFault {
Message = ex.Message
},
RequestIndex = i
});
if (!executeMultipleRequest.Settings.ContinueOnError)
{
break;
}
}
}
// Implement response behaviour as in https://msdn.microsoft.com/en-us/library/jj863631.aspx
if (executeMultipleRequest.Settings.ReturnResponses)
{
response.Results["response.Responses"] = response.Responses;
}
else if (response.Responses.Any(resp => resp.Fault != null))
{
var failures = new ExecuteMultipleResponseItemCollection();
failures.AddRange(response.Responses.Where(resp => resp.Fault != null));
response.Results["response.Responses"] = failures;
}
return(response);
}
private static IEnumerable <XElement> GetContentValues(OrganizationResponse response)
{
yield return(new XElement(response.ResponseName, GetContentValues(response.Results)));
}
