public static CustomAccount ConvertToReadableAccount(Xrm.Account orig)
{
CustomAccount ca = new CustomAccount();
ca.Id = orig.Id;
ca.Name = orig.Name;
return ca;
}
void QuoteProduct_PropertyChanged(object sender, Xrm.ComponentModel.PropertyChangedEventArgs e)
{
if (Quantity != null && PricePerUnit != null)
{
this.ExtendedAmount = new Money(Quantity.Value * PricePerUnit.Value);
}
this.IsProductOverridden = !String.IsNullOrEmpty(ProductDescription);
}
public static Contact ConvertToEFObject(Xrm.Domain.Contact.Contact contact)
{
return new Contact
{
ContactId = contact.Id,
Firstname = contact.Firstname,
Lastname = contact.Lastname,
Email = contact.EmailAddress1
};
}
private void connection_PropertyChanged(object sender, Xrm.ComponentModel.PropertyChangedEventArgs e)
{
Connection connectionToUpdate = new Connection();
Connection updated = (Connection)sender;
connectionToUpdate.ConnectionID = new Guid(updated.Id);
bool updateRequired = false;
switch (e.PropertyName)
{
case "record2roleid":
// Check if the record1id is loaded - if not load it now so we can work out the opposite role
if (updated.Record1Id == null)
{
Connection connection = (Connection) OrganizationServiceProxy.Retrieve(Connection.LogicalName,updated.ConnectionID.Value,new string[] {"record1id"});
updated.Record1Id = connection.Record1Id;
}
connectionToUpdate.Record2RoleId = updated.Record2RoleId;
connectionToUpdate.Record1RoleId = ObservableConnection.GetOppositeRole(updated.Record2RoleId, updated.Record1Id);
updateRequired = true;
break;
case "description":
connectionToUpdate.Description = updated.Description;
updateRequired = true;
break;
case "effectivestart":
connectionToUpdate.EffectiveStart = updated.EffectiveStart;
updateRequired = true;
break;
case "effectiveend":
connectionToUpdate.EffectiveEnd = updated.EffectiveEnd;
updateRequired = true;
break;
}
// Auto save
if (updateRequired)
{
OrganizationServiceProxy.BeginUpdate(connectionToUpdate, delegate(object state)
{
try
{
OrganizationServiceProxy.EndUpdate(state);
ErrorMessage.SetValue(null);
}
catch (Exception ex)
{
ErrorMessage.SetValue(ex.Message);
}
});
}
}
public static CustomOpportunity ConvertToReadableOpportunity(Xrm.Opportunity orig)
{
CustomOpportunity co = new CustomOpportunity();
co.Id = orig.Id;
co.OpportunityId = orig.OpportunityId.Value;
co.Name = orig.Name;
co.Description = orig.Description;
co.ProjectDescription = orig.new_ProjectDescription;
co.ProjectRationale = orig.new_ProjectRationale;
//orig.cov
return co;
}
public void connection_PropertyChanged(object sender, Xrm.ComponentModel.PropertyChangedEventArgs e)
{
if(e.PropertyName == "record1roleid")
{
Connection update = (Connection)sender;
Connection connectionToUpdate = new Connection();
connectionToUpdate.ConnectionId = new Guid(update.Id);
connectionToUpdate.Record1RoleId = update.Record1RoleId;
OrganizationServiceProxy.BeginUpdate(connectionToUpdate, delegate(object state)
{
try
{
OrganizationServiceProxy.EndUpdate(state);
ErrorMessage.SetValue(null);
}
catch (Exception ex)
{
ErrorMessage.SetValue(ex.Message);
}
});
}
}
public void When_ordering_by_money_fields_descending_expected_result_is_returned()
{
using (var context = new Xrm(orgAdminService))
{
var contact1 = new Contact
{
Id = Guid.NewGuid(),
FirstName = "Fred",
LastName = "Bloggs",
AnnualIncome = 12345m,
TransactionCurrencyId = crm.BaseCurrency
};
var contact2 = new Contact
{
Id = Guid.NewGuid(),
FirstName = "Jo",
LastName = "Bloggs",
AnnualIncome = 678910m,
TransactionCurrencyId = crm.BaseCurrency
};
crm.PopulateWith(contact1, contact2);
QueryExpression qry = new QueryExpression(Contact.EntityLogicalName)
{
ColumnSet = new ColumnSet(true)
};
qry.AddOrder("annualincome", OrderType.Descending);
var results = orgAdminService.RetrieveMultiple(qry);
var firstResultValue = (results.Entities[0] as Contact).AnnualIncome;
Assert.Equal(678910M, firstResultValue.Value);
}
}
public void TestNestedJoinsLinkedSelectOnId()
{
using (var context = new Xrm(orgAdminUIService))
{
var res = contact1.Id;
EntityReferenceCollection relatedEntities = new EntityReferenceCollection
{
new EntityReference(Account.EntityLogicalName, account1.Id),
new EntityReference(Account.EntityLogicalName, account2.Id)
};
orgAdminUIService.Associate(
Contact.EntityLogicalName, contact1.Id, new Relationship("account_primary_contact"), relatedEntities);
var query =
from con in context.ContactSet
join acc in context.AccountSet
on con.ContactId equals acc.PrimaryContactId.Id
join lead in context.LeadSet
on acc.AccountId equals lead.ParentAccountId.Id
where con.Id == res
select new { con.Id, con.LastName, acc.Name, lead.Subject };
var result = query.AsEnumerable().Where(x => x.Subject.StartsWith("Some"));
Assert.Equal(4, result.Count());
foreach (var r in result)
{
Assert.Equal(contact1.LastName, r.LastName);
Assert.True(account1.Name == r.Name || account2.Name == r.Name);
Assert.StartsWith("Some", r.Subject);
}
}
}
public void When_execute_is_called_with_a_non_existing_target_exception_is_thrown()
{
using (var context = new Xrm(orgAdminUIService))
{
EntityReferenceCollection relatedEntities = new EntityReferenceCollection
{
new EntityReference(Account.EntityLogicalName, account1.Id),
new EntityReference(Account.EntityLogicalName, account2.Id),
new EntityReference(Account.EntityLogicalName, account3.Id)
};
Relationship relationship = new Relationship("account_primary_contact");
try
{
orgAdminUIService.Associate(Contact.EntityLogicalName, Guid.NewGuid(), relationship,
relatedEntities);
throw new XunitException();
}
catch (Exception e)
{
Assert.IsType <FaultException>(e);
}
}
}
public void TestUpdateObject()
{
using (var context = new Xrm(orgAdminUIService))
{
var lead = new Lead
{
FirstName = "Before"
};
orgAdminUIService.Create(lead);
var leadFromContext = context.LeadSet.First();
leadFromContext.FirstName = "After";
context.SaveChanges();
Assert.Equal(lead.FirstName, context.LeadSet.First().FirstName);
context.ClearChanges();
context.Attach(leadFromContext);
context.UpdateObject(leadFromContext);
context.SaveChanges();
Assert.Equal(leadFromContext.FirstName, context.LeadSet.First().FirstName);
context.ClearChanges();
}
}
public void When_ordering_by_datetime_descending_fields_expected_result_is_returned()
{
using (var context = new Xrm(orgAdminService)) {
var now = DateTime.Now;
var contact1 = new Contact();
contact1.FirstName = "Fred";
contact1.LastOnHoldTime = now;
contact1.Id = orgAdminService.Create(contact1);
var contact2 = new Contact();
contact2.FirstName = "Jo";
contact2.LastOnHoldTime = now.AddDays(1);
contact2.Id = orgAdminService.Create(contact2);
QueryExpression qry = new QueryExpression(Contact.EntityLogicalName);
qry.ColumnSet = new ColumnSet(true);
qry.AddOrder("lastonholdtime", OrderType.Descending);
var results = orgAdminService.RetrieveMultiple(qry);
var firstResultValue = (results.Entities[0] as Contact).LastOnHoldTime;
Assert.AreEqual(now.AddDays(1), firstResultValue.Value);
}
}
public void TestContextIntersectEntity()
{
using (var context = new Xrm(orgAdminUIService))
{
var acc1 = orgAdminUIService.Create(new Account());
var acc2 = orgAdminUIService.Create(new Account());
var acc3 = orgAdminUIService.Create(new Account());
var con = orgAdminUIService.Create(new Contact());
var relatedAccounts = new EntityReferenceCollection
{
new EntityReference(Account.EntityLogicalName, acc1),
new EntityReference(Account.EntityLogicalName, acc2),
new EntityReference(Account.EntityLogicalName, acc3)
};
Relationship relationship = new Relationship(dg_account_contact.EntityLogicalName);
orgAdminUIService.Associate(Contact.EntityLogicalName, con, relationship, relatedAccounts);
Assert.AreEqual(3, context.dg_account_contactSet.Where(x => x.contactid == con).ToList().Count());
}
}
public void TestReferenceHasPrimaryAttribute()
{
using (var context = new Xrm(orgAdminUIService)) {
var id1 = this.orgAdminUIService.Create(new Account()
{
Name = "MLJ UnitTest"
});
var id2 = this.orgAdminUIService.Create(new Account()
{
Name = "MLJ UnitTest2"
});
var acc1a = new Account(id1)
{
ParentAccountId = new EntityReference(Account.EntityLogicalName, id2)
};
this.orgAdminUIService.Update(acc1a);
var retrieved = this.orgAdminUIService.Retrieve(Account.EntityLogicalName, id1,
new ColumnSet("accountid", "parentaccountid")).ToEntity <Account>();
Assert.IsNotNull(retrieved.ParentAccountId);
Assert.AreEqual(retrieved.Id, id1);
}
}
public void TestCalculatedIsSet()
{
var bus = new dg_bus();
bus.dg_name = "Buu";
bus.Id = orgAdminUIService.Create(bus);
using (var context = new Xrm(orgAdminUIService))
{
var retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.IsNull(retrieved.dg_Udregnet);
}
bus.dg_name = "Woop";
orgAdminUIService.Update(bus);
using (var context = new Xrm(orgAdminUIService))
{
var retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.IsNull(retrieved.dg_Udregnet);
Assert.IsNull(bus.dg_AllConditions);
}
bus.dg_Ticketprice = 30;
bus.dg_EtHelTal = 5;
bus.dg_Udkoerselsdato = DateTime.Now;
orgAdminUIService.Update(bus);
using (var context = new Xrm(orgAdminUIService))
{
var retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.AreEqual(bus.dg_Ticketprice * 20, retrieved.dg_Udregnet);
Assert.AreEqual(bus.dg_EtHelTal - 2, retrieved.dg_WholenumberUdregnet);
Assert.AreEqual(bus.dg_Udkoerselsdato.Value.AddDays(2), retrieved.dg_DateTimeUdregnet);
Assert.AreEqual(bus.dg_name.Substring(2), retrieved.dg_TrimLeft);
Assert.IsNotNull(retrieved.dg_AllConditions);
}
}
public void TestPrecisionSource()
{
using (var context = new Xrm(orgAdminUIService)) {
var currency = new TransactionCurrency()
{
ExchangeRate = 1m,
CurrencyPrecision = 3
};
currency.Id = orgAdminUIService.Create(currency);
var bus = new dg_bus()
{
dg_name = "Woop",
dg_Ticketprice = 10.1234m,
TransactionCurrencyId = currency.ToEntityReference()
};
bus.Id = orgAdminUIService.Create(bus);
var retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.AreEqual(Math.Round(bus.dg_Ticketprice.Value, currency.CurrencyPrecision.Value), retrieved.dg_Ticketprice.Value);
Assert.AreEqual(Math.Round(Math.Round(bus.dg_Ticketprice.Value, currency.CurrencyPrecision.Value) * 20, 2), retrieved.dg_Udregnet.Value);
Assert.AreEqual(Math.Round(Math.Round(bus.dg_Ticketprice.Value, currency.CurrencyPrecision.Value) * 20, 1), retrieved.dg_EndnuUdregnet.Value);
}
}
public void TestUserCurrencyIsChosen()
{
using (var context = new Xrm(orgAdminUIService)) {
var currentUser = orgAdminUIService.Retrieve(SystemUser.EntityLogicalName, crm.AdminUser.Id, new ColumnSet(true)).ToEntity <SystemUser>();
var currency = new TransactionCurrency();
currency.ExchangeRate = 0.5m;
currency.CurrencyPrecision = 3;
currency.Id = orgAdminUIService.Create(currency);
currentUser.TransactionCurrencyId = currency.ToEntityReference();
orgAdminUIService.Update(currentUser);
var bus = new dg_bus();
bus.dg_Ticketprice = 10m;
var busId = orgAdminUIService.Create(bus);
var retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, busId, new ColumnSet(true)) as dg_bus;
Assert.AreEqual(currency.ToEntityReference(), retrieved.TransactionCurrencyId);
bus.dg_Ticketprice = 20m;
orgAdminUIService.Update(bus);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, busId, new ColumnSet(true)) as dg_bus;
Assert.AreEqual(currency.ToEntityReference(), retrieved.TransactionCurrencyId);
}
}
public void TestRetrieveHasId()
{
using (var context = new Xrm(orgAdminUIService))
{
var accountName = "Litware, Inc.";
var _accountId = orgAdminUIService.Create(
new Account
{
Name = accountName,
Address1_StateOrProvince = "Colorado"
});
var entity = (Account)orgAdminUIService.Retrieve(Account.EntityLogicalName, _accountId, new ColumnSet(true));
Assert.Equal(_accountId, entity.Id);
entity = (Account)orgAdminUIService.Retrieve(Account.EntityLogicalName, _accountId, new ColumnSet("name"));
Assert.Equal(_accountId, entity.Id);
var calId = orgAdminUIService.Create(new Entity("calendar"));
var cal = orgAdminUIService.Retrieve("calendar", calId, new ColumnSet(true));
Assert.Equal(calId, cal.Id);
cal = orgAdminUIService.Retrieve("calendar", calId, new ColumnSet("createdby"));
Assert.Equal(calId, cal.Id);
}
}
public void TestCascadeDeleteChildToParents()
{
using (var context = new Xrm(orgAdminUIService))
{
var fetchedAccount1 = context.AccountSet.FirstOrDefault(x => x.Id == acc1.Id);
Assert.AreEqual(crm.AdminUser.Id, fetchedAccount1.OwnerId.Id);
var fetchedAccount2 = context.AccountSet.FirstOrDefault(x => x.Id == acc2.Id);
Assert.AreEqual(crm.AdminUser.Id, fetchedAccount2.OwnerId.Id);
var fetchedContact = context.ContactSet.FirstOrDefault(x => x.Id == contact.Id);
Assert.AreEqual(crm.AdminUser.Id, fetchedContact.OwnerId.Id);
}
orgAdminUIService.Delete(Contact.EntityLogicalName, contact.Id);
using (var context = new Xrm(orgAdminUIService))
{
var fetchedAccount1 = context.AccountSet.FirstOrDefault(x => x.Id == acc1.Id);
Assert.IsNotNull(fetchedAccount1);
var fetchedAccount2 = context.AccountSet.FirstOrDefault(x => x.Id == acc2.Id);
Assert.IsNotNull(fetchedAccount2);
var fetchedContact = context.ContactSet.FirstOrDefault(x => x.Id == contact.Id);
Assert.IsNull(fetchedContact);
}
}
public void TestExchangeRate()
{
using (var context = new Xrm(orgAdminUIService))
{
var dollar = new TransactionCurrency
{
ExchangeRate = 0.6m,
CurrencyPrecision = 3
};
var dollarId = orgAdminUIService.Create(dollar);
dollar.Id = dollarId;
var bus = new dg_bus
{
dg_Ticketprice = 10m,
TransactionCurrencyId = dollar.ToEntityReference()
};
var busId = orgAdminUIService.Create(bus);
var retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, busId, new ColumnSet(true)) as dg_bus;
Assert.True(retrieved.dg_ticketprice_Base.HasValue);
Assert.Equal(Math.Round(bus.dg_Ticketprice.Value / dollar.ExchangeRate.Value, dollar.CurrencyPrecision.Value), retrieved.dg_ticketprice_Base.Value);
}
}
public void MoveMemberFromBUOneToBUTwo()
{
var retrievedUser = orgAdminService.Retrieve("systemuser", _user2.Id, new ColumnSet("businessunitid"));
retrievedUser.Attributes["businessunitid"] = _businessUnit4.ToEntityReference();
// retrievedUser.Attributes["name"] = "Just changed the name ;)";
orgAdminService.Update(retrievedUser);
var team3 = RetrieveBusinessUnitDefaultTeamAndCheckAttributes(_businessUnit3);
var team4 = RetrieveBusinessUnitDefaultTeamAndCheckAttributes(_businessUnit4);
using (var context = new Xrm(orgAdminService))
{
var fetchedTeam = context.TeamMembershipSet.Where(x => x.TeamId == team3.Id).ToList();
Assert.AreEqual(0, fetchedTeam.Count);
}
using (var context = new Xrm(orgAdminService))
{
var fetchedTeam = context.TeamMembershipSet.Where(x => x.TeamId == team4.Id).ToList();
Assert.AreEqual(1, fetchedTeam.Count);
}
}
public void TestOwningBusinessUnitValidNameWorkflow()
{
using (var context = new Xrm(orgAdminUIService))
{
crm.AddWorkflow(Path.Combine("../../..", "Metadata", "Workflows", "OwningBUWorkflow.xml"));
var businessunit = new BusinessUnit
{
Name = "delegatelab4"
};
businessunit.Id = orgAdminUIService.Create(businessunit);
var user = crm.CreateUser(orgAdminUIService, businessunit.ToEntityReference(), SecurityRoles.SystemAdministrator) as SystemUser;
var service = crm.CreateOrganizationService(user.Id);
var acc = new Account
{
Name = "Some name"
};
acc.Id = service.Create(acc);
var retrieved = orgAdminUIService.Retrieve(Account.EntityLogicalName, acc.Id, new ColumnSet(true)) as Account;
Assert.AreEqual("SetOwningBU", retrieved.Name);
}
}
public void TestQueryExpressionNotInEmpty()
{
var leadCount = 0;
using (var context = new Xrm(orgAdminUIService))
{
leadCount = context.LeadSet.Select(x => x.LeadId).ToList().Count();
}
var query = new QueryExpression("lead")
{
ColumnSet = new ColumnSet(true)
};
var filter = new FilterExpression(LogicalOperator.And);
filter.AddCondition(new ConditionExpression("parentcontactid", ConditionOperator.NotIn, new Guid[] { }));
query.Criteria = filter;
var res = orgAdminService.RetrieveMultiple(query).Entities.Cast <Lead>();
Assert.AreEqual(leadCount, res.Count());
}
public void When_execute_is_called_with_a_non_existing_reference_exception_is_thrown()
{
using (var context = new Xrm(orgAdminUIService))
{
EntityReferenceCollection relatedEntities = new EntityReferenceCollection
{
new EntityReference(Account.EntityLogicalName, account1.Id),
new EntityReference(Account.EntityLogicalName, Guid.NewGuid()),
new EntityReference(Account.EntityLogicalName, account3.Id)
};
Relationship relationship = new Relationship("account_primary_contact");
try
{
orgAdminUIService.Associate(Contact.EntityLogicalName, contact1.Id, relationship,
relatedEntities);
Assert.Fail();
}
catch (Exception e)
{
Assert.IsInstanceOfType(e, typeof(FaultException));
}
}
}
protected override void Execute(CodeActivityContext executionContext)
{
// Create the tracing service
ITracingService tracingService = executionContext.GetExtension <ITracingService>();
if (tracingService == null)
{
throw new InvalidPluginExecutionException("Failed to retrieve tracing service.");
}
tracingService.Trace("Entered AddTabelArrangementProductToBooking.Execute(), Activity Instance Id: {0}, Workflow Instance Id: {1}",
executionContext.ActivityInstanceId,
executionContext.WorkflowInstanceId);
// Create the context
IWorkflowContext context = executionContext.GetExtension <IWorkflowContext>();
if (context == null)
{
throw new InvalidPluginExecutionException("Failed to retrieve workflow context.");
}
tracingService.Trace("AddTabelArrangementProductToBooking.Execute(), Correlation Id: {0}, Initiating User: {1}",
context.CorrelationId,
context.InitiatingUserId);
IOrganizationServiceFactory serviceFactory = executionContext.GetExtension <IOrganizationServiceFactory>();
IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
Xrm xrm = new Xrm(service);
tracingService.Trace("Creating AddTabelArrangementProductToBooking...");
try
{
var bookingResRef = BookableResourceRef.Get <EntityReference>(executionContext);
var br = xrm.BookableResourceSet.FirstOrDefault(b => b.BookableResourceId.Value == bookingResRef.Id);
EntityReferenceCollection enColl = new EntityReferenceCollection();
var udstyr = (from ur in xrm.dyna_dyna_udstyr_bookableresourceSet
join u in xrm.dyna_udstyrSet on ur.dyna_udstyrid equals u.dyna_udstyrId
where ur.bookableresourceid.Value == bookingResRef.Id
select u).ToList();
foreach (var item in udstyr)
{
var be = new dyna_bookingequipment()
{
dyna_Amount = 1,
dyna_UseEquipmentAs = false,
dyna_EquipmentId = item.ToEntityReference(),
dyna_BookableResourceBookingId = new EntityReference(BookableResourceBooking.EntityLogicalName, context.PrimaryEntityId)
};
service.Create(be);
}
tracingService.Trace("Done.");
}
catch (FaultException <OrganizationServiceFault> e)
{
tracingService.Trace("Exception: {0} - {1}", e.ToString(), e.StackTrace);
// Handle the exception.
throw;
}
tracingService.Trace("Exiting AddTabelArrangementProductToBooking.Execute(), Correlation Id: {0}", context.CorrelationId);
}
static void Main(string[] args)
{
SystemUser user1;
Account acc1;
Account acc2;
Contact contact;
var settings = new XrmMockupSettings
{
BasePluginTypes = new Type[] { },
CodeActivityInstanceTypes = new Type[] { },
EnableProxyTypes = true,
IncludeAllWorkflows = false,
ExceptionFreeRequests = new string[] { "TestWrongRequest" },
MetadataDirectoryPath = "../../Metadata"
,
DatabaseConnectionString = "Server=.;Database=XrmMockup;Trusted_Connection=True;"
,
RecreateDatabase = false
};
var crm = XrmMockup365.GetInstance(settings);
var orgAdminUIService = crm.GetAdminService(new MockupServiceSettings(true, false, MockupServiceSettings.Role.UI));
var orgGodService = crm.GetAdminService(new MockupServiceSettings(false, true, MockupServiceSettings.Role.SDK));
var orgAdminService = crm.GetAdminService();
user1 = crm.CreateUser(orgGodService, crm.RootBusinessUnit, new Guid("b6495cab-c047-e611-80d9-c4346badf080")).ToEntity <SystemUser>();
acc1 = new Account()
{
Name = "Parent Account"
};
acc1.Id = orgAdminUIService.Create(acc1);
acc2 = new Account()
{
Name = "Account",
ParentAccountId = acc1.ToEntityReference()
};
acc2.Id = orgAdminUIService.Create(acc2);
contact = new Contact()
{
FirstName = "Child Contact",
LastName = "Test",
ParentCustomerId = acc2.ToEntityReference()
};
contact.Id = orgAdminUIService.Create(contact);
using (var context = new Xrm(orgAdminUIService))
{
var accountSet = context.AccountSet.ToList();
var fetchedAccount1 = accountSet.FirstOrDefault(x => x.Id == acc1.Id);
var fetchedAccount2 = accountSet.FirstOrDefault(x => x.Id == acc2.Id);
var fetchedContact = context.ContactSet.FirstOrDefault(x => x.Id == contact.Id);
var req = new AssignRequest()
{
Assignee = user1.ToEntityReference(),
Target = acc1.ToEntityReference()
};
orgAdminUIService.Execute(req);
using (var context2 = new Xrm(orgAdminUIService))
{
accountSet = context2.AccountSet.ToList();
fetchedAccount1 = accountSet.FirstOrDefault(x => x.Id == acc1.Id);
fetchedAccount2 = accountSet.FirstOrDefault(x => x.Id == acc2.Id);
fetchedContact = context2.ContactSet.FirstOrDefault(x => x.Id == contact.Id);
}
}
}
void quote_PropertyChanged(object sender, Xrm.ComponentModel.PropertyChangedEventArgs e)
{
Window.SetTimeout(delegate() { Lines.Refresh(); }, 0);
}
public void TestRollUp()
{
using (var context = new Xrm(orgAdminUIService))
{
var childlessBus = new dg_bus()
{
dg_name = "Buu"
};
childlessBus.Id = orgAdminUIService.Create(childlessBus);
var retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, childlessBus.Id, new ColumnSet(true)) as dg_bus;
Assert.IsNull(retrieved.dg_Totalallowance);
childlessBus.dg_name = "Woop";
orgAdminUIService.Update(childlessBus);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, childlessBus.Id, new ColumnSet(true)) as dg_bus;
Assert.IsNull(retrieved.dg_Totalallowance);
var bus = new dg_bus {
dg_name = "Woop"
};
bus.Id = orgAdminUIService.Create(bus);
orgAdminUIService.Create(
new dg_child()
{
dg_name = "Hans Jørgen",
dg_Allowance = 20,
dg_Skolebus = new EntityReference
{
Id = bus.Id,
LogicalName = dg_bus.EntityLogicalName
}
});
orgAdminUIService.Create(
new dg_child()
{
dg_name = "Hans Gert",
dg_Allowance = 50,
dg_Skolebus = new EntityReference
{
Id = bus.Id,
LogicalName = dg_bus.EntityLogicalName
}
});
var anotherCurrency = new TransactionCurrency()
{
ExchangeRate = 0.5m,
CurrencyPrecision = 2
};
anotherCurrency.Id = orgAdminUIService.Create(anotherCurrency);
orgAdminUIService.Create(
new dg_child()
{
dg_name = "Børge Hansen",
dg_Allowance = 30,
dg_Skolebus = new EntityReference
{
Id = bus.Id,
LogicalName = dg_bus.EntityLogicalName
},
TransactionCurrencyId = anotherCurrency.ToEntityReference()
});
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.IsNull(retrieved.dg_Totalallowance);
Assert.IsNull(retrieved.dg_MaxAllowance);
Assert.IsNull(retrieved.dg_MinAllowance);
Assert.IsNull(retrieved.dg_AvgAllowance);
var req = new CalculateRollupFieldRequest()
{
FieldName = "dg_totalallowance",
Target = bus.ToEntityReference()
};
orgAdminUIService.Execute(req);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.AreEqual(130, retrieved.dg_Totalallowance);
Assert.IsNull(retrieved.dg_MaxAllowance);
Assert.IsNull(retrieved.dg_MinAllowance);
Assert.IsNull(retrieved.dg_AvgAllowance);
req.FieldName = "dg_maxallowance";
orgAdminUIService.Execute(req);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.AreEqual(130, retrieved.dg_Totalallowance);
Assert.AreEqual(60, retrieved.dg_MaxAllowance);
Assert.IsNull(retrieved.dg_MinAllowance);
Assert.IsNull(retrieved.dg_AvgAllowance);
req.FieldName = "dg_minallowance";
orgAdminUIService.Execute(req);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.AreEqual(130, retrieved.dg_Totalallowance);
Assert.AreEqual(60, retrieved.dg_MaxAllowance);
Assert.AreEqual(20, retrieved.dg_MinAllowance);
Assert.IsNull(retrieved.dg_AvgAllowance);
req.FieldName = "dg_avgallowance";
orgAdminUIService.Execute(req);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.AreEqual(130, retrieved.dg_Totalallowance.Value);
Assert.AreEqual(60, retrieved.dg_MaxAllowance.Value);
Assert.AreEqual(20, retrieved.dg_MinAllowance.Value);
Assert.AreEqual(43.33m, retrieved.dg_AvgAllowance.Value);
}
}
protected override void Execute(CodeActivityContext executionContext)
{
// Create the tracing service
ITracingService tracingService = executionContext.GetExtension <ITracingService>();
if (tracingService == null)
{
throw new InvalidPluginExecutionException("Failed to retrieve tracing service.");
}
tracingService.Trace("Entered AddTabelArrangementProductToBooking.Execute(), Activity Instance Id: {0}, Workflow Instance Id: {1}",
executionContext.ActivityInstanceId,
executionContext.WorkflowInstanceId);
// Create the context
IWorkflowContext context = executionContext.GetExtension <IWorkflowContext>();
if (context == null)
{
throw new InvalidPluginExecutionException("Failed to retrieve workflow context.");
}
tracingService.Trace("AddTabelArrangementProductToBooking.Execute(), Correlation Id: {0}, Initiating User: {1}",
context.CorrelationId,
context.InitiatingUserId);
IOrganizationServiceFactory serviceFactory = executionContext.GetExtension <IOrganizationServiceFactory>();
IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
Xrm xrm = new Xrm(service);
tracingService.Trace("Creating AddTabelArrangementProductToBooking...");
try
{
var tableRef = TableArrangement.Get <EntityReference>(executionContext);
var bookingRef = Booking.Get <EntityReference>(executionContext);
var accomRef = Accomondationtype.Get <EntityReference>(executionContext);
var table = xrm.dyna_tablearrangementSet.FirstOrDefault(t => t.dyna_tablearrangementId.Value == tableRef.Id);
var booking = xrm.dyna_bookingSet.FirstOrDefault(b => b.ActivityId.Value == bookingRef.Id);
if (!table.dyna_Default.Value)
{
if (table.dyna_ProductId != null)
{
var pro = xrm.ProductSet.FirstOrDefault(p => p.ProductId.Value == table.dyna_ProductId.Id);
double antal = 1;
if (booking.dyna_bookingtype.Value == 378080003)
{
antal = 1; //Math.Round(double.Parse((booking.ScheduledDurationMinutes.Value / 60 / 24).ToString("F2")), MidpointRounding.AwayFromZero);
}
dyna_bookingproductline bpl = new dyna_bookingproductline();
bpl.dyna_AccommodationTypeId = accomRef;
bpl.dyna_count = int.Parse(antal.ToString());
// bpl.dyna_LokaleType = new OptionSetValue(378080000);
bpl.dyna_price = pro.Price;
bpl.dyna_useprice = pro.Price;
bpl.dyna_productid = pro.ToEntityReference();
bpl.dyna_name = pro.Name;
bpl.dyna_bookingid = booking.dyna_parentbookingid != null ? booking.dyna_parentbookingid : booking.ToEntityReference();
service.Create(bpl);
}
}
tracingService.Trace("Done.");
}
catch (FaultException <OrganizationServiceFault> e)
{
tracingService.Trace("Exception: {0} - {1}", e.ToString(), e.StackTrace);
// Handle the exception.
throw;
}
tracingService.Trace("Exiting AddTabelArrangementProductToBooking.Execute(), Correlation Id: {0}", context.CorrelationId);
}
protected override void Execute(CodeActivityContext executionContext)
{
// Create the tracing service
ITracingService tracingService = executionContext.GetExtension <ITracingService>();
if (tracingService == null)
{
throw new InvalidPluginExecutionException("Failed to retrieve tracing service.");
}
tracingService.Trace("Entered AddOrderProduct.Execute(), Activity Instance Id: {0}, Workflow Instance Id: {1}",
executionContext.ActivityInstanceId,
executionContext.WorkflowInstanceId);
// Create the context
IWorkflowContext context = executionContext.GetExtension <IWorkflowContext>();
if (context == null)
{
throw new InvalidPluginExecutionException("Failed to retrieve workflow context.");
}
tracingService.Trace("AddOrderProduct.Execute(), Correlation Id: {0}, Initiating User: {1}",
context.CorrelationId,
context.InitiatingUserId);
IOrganizationServiceFactory serviceFactory = executionContext.GetExtension <IOrganizationServiceFactory>();
IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
Xrm xrm = new Xrm(service);
tracingService.Trace("Creating Order Product...");
SalesOrderDetail sod = new SalesOrderDetail();
var orderRef = RelatedOrder.Get <EntityReference>(executionContext);
var order = xrm.SalesOrderSet.First(f => f.SalesOrderId.Value == orderRef.Id);
try
{
tracingService.Trace("Order: {0} - {1}", orderRef.Id, orderRef.Name);
var productDiscount = TotalDiscount.Get <Money>(executionContext);
tracingService.Trace("Total Discount: {0}", productDiscount.Value);
tracingService.Trace("Service 1: {0}", service != null ? true : false);
var booking = xrm.dyna_bookingSet.FirstOrDefault(w => w.ActivityId.Value == order.dyna_BookingId.Id);
if (booking.dyna_bookingtype.Value == 378080001 || booking.dyna_bookingtype.Value == 378080000 || booking.dyna_bookingtype.Value == 378080002)
{
var forplejning = xrm.dyna_bookingproductlineSet.Where(x => x.dyna_bookingid.Id == order.dyna_BookingId.Id).ToList();
foreach (var item in forplejning)
{
var sodFor = new SalesOrderDetail();
var proFor = (Product)service.Retrieve(Product.EntityLogicalName, item.dyna_productid.Id, new ColumnSet(true));
sodFor.Quantity = Convert.ToDecimal(item.dyna_count.Value.ToString());
sodFor.PricePerUnit = new Money(item.dyna_useprice.Value);
sodFor.ProductId = proFor.ToEntityReference();
sodFor.UoMId = proFor.DefaultUoMId;
sodFor.IsPriceOverridden = true;
sodFor.BaseAmount = new Money(item.dyna_count.Value * item.dyna_useprice.Value);
sodFor.SalesOrderId = new EntityReference(SalesOrder.EntityLogicalName, orderRef.Id);
//Dette bruges til hvis der er ændringer i prisen i forhold til produkt prisen.
//sodFor.ManualDiscountAmount = new Money((item.dyna_Antal.Value * proFor.Price.Value) - (item.dyna_Antal.Value * item.dyna_AnvendPris.Value));
sodFor.Description = item.dyna_description;
service.Create(sodFor);
}
var or = new SalesOrder();
or.SalesOrderId = order.Id;
or.DiscountAmount = productDiscount;
service.Update(or);
}
//else if(booking.dyna_Bookingtype.Value == 378080000) //Undervisning
//{
// var pro = (Product)service.Retrieve(Product.EntityLogicalName, booking.dyna_ProductId.Id, new ColumnSet(true));
// var sodFor = new SalesOrderDetail();
// sodFor.Quantity = Convert.ToDecimal(1);
// sodFor.PricePerUnit = new Money(pro.Price.Value);
// sodFor.ProductId = pro.ToEntityReference();
// sodFor.UoMId = pro.DefaultUoMId;
// sodFor.BaseAmount = new Money(pro.Price.Value);
// sodFor.SalesOrderId = new EntityReference(SalesOrder.EntityLogicalName, orderRef.Id);
// service.Create(sodFor);
//}
tracingService.Trace("Done.");
}
catch (FaultException <OrganizationServiceFault> e)
{
tracingService.Trace("Exception: {0} - {1}", e.ToString(), e.StackTrace);
// Handle the exception.
throw;
}
tracingService.Trace("Exiting AddOrderProduct.Execute(), Correlation Id: {0}", context.CorrelationId);
}
public void TestAssocDissocNN()
{
using (var context = new Xrm(orgAdminUIService))
{
var relatedAccounts = new EntityReferenceCollection();
relatedAccounts.Add(new EntityReference(Account.EntityLogicalName, account1.Id));
relatedAccounts.Add(new EntityReference(Account.EntityLogicalName, account2.Id));
relatedAccounts.Add(new EntityReference(Account.EntityLogicalName, account3.Id));
var relatedContacts = new EntityReferenceCollection();
relatedContacts.Add(new EntityReference(Contact.EntityLogicalName, contact1.Id));
relatedContacts.Add(new EntityReference(Contact.EntityLogicalName, contact2.Id));
Relationship relationship = new Relationship(dg_account_contact.EntityLogicalName);
orgAdminUIService.Associate(Contact.EntityLogicalName, contact1.Id, relationship, relatedAccounts);
orgAdminUIService.Associate(Contact.EntityLogicalName, contact2.Id, relationship, relatedAccounts);
var relationQuery = new RelationshipQueryCollection();
var query = new QueryExpression(Account.EntityLogicalName);
query.ColumnSet = new ColumnSet("name");
relationQuery.Add(relationship, query);
var req = new RetrieveRequest();
req.ColumnSet = new ColumnSet("firstname");
req.RelatedEntitiesQuery = relationQuery;
req.Target = new EntityReference(Contact.EntityLogicalName, contact1.Id);
var retrievedContact = (orgAdminUIService.Execute(req) as RetrieveResponse).Entity as Contact;
var related = retrievedContact.RelatedEntities[relationship].Entities;
Assert.AreEqual(3, related.Count());
Assert.AreEqual(account1.Id, related.FirstOrDefault(e => (e as Account).Name == account1.Name).Id);
Assert.AreEqual(account2.Id, related.FirstOrDefault(e => (e as Account).Name == account2.Name).Id);
Assert.AreEqual(account3.Id, related.FirstOrDefault(e => (e as Account).Name == account3.Name).Id);
orgAdminUIService.Disassociate(Contact.EntityLogicalName, contact1.Id, relationship, relatedAccounts);
relationQuery = new RelationshipQueryCollection();
query = new QueryExpression(Account.EntityLogicalName);
query.ColumnSet = new ColumnSet("name");
relationQuery.Add(relationship, query);
req = new RetrieveRequest();
req.ColumnSet = new ColumnSet("firstname");
req.RelatedEntitiesQuery = relationQuery;
req.Target = new EntityReference(Contact.EntityLogicalName, contact1.Id);
retrievedContact = (orgAdminUIService.Execute(req) as RetrieveResponse).Entity as Contact;
Assert.AreEqual(0, retrievedContact.RelatedEntities.Count());
relationQuery = new RelationshipQueryCollection();
query = new QueryExpression(Account.EntityLogicalName);
query.ColumnSet = new ColumnSet("name");
relationQuery.Add(relationship, query);
req = new RetrieveRequest();
req.ColumnSet = new ColumnSet("firstname");
req.RelatedEntitiesQuery = relationQuery;
req.Target = new EntityReference(Contact.EntityLogicalName, contact2.Id);
retrievedContact = (orgAdminUIService.Execute(req) as RetrieveResponse).Entity as Contact;
related = retrievedContact.RelatedEntities[relationship].Entities;
Assert.AreEqual(3, related.Count());
Assert.AreEqual(account1.Id, related.FirstOrDefault(e => (e as Account).Name == account1.Name).Id);
Assert.AreEqual(account2.Id, related.FirstOrDefault(e => (e as Account).Name == account2.Name).Id);
Assert.AreEqual(account3.Id, related.FirstOrDefault(e => (e as Account).Name == account3.Name).Id);
}
}
public void ContextJoinTest()
{
using (var context = new Xrm(this.orgAdminUIService))
{
var acc1 = new Account()
{
Name = "MLJ UnitTest " + DateTime.Now.ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture)
};
var id1 = orgAdminUIService.Create(acc1);
var acc2 = new Account()
{
Name = "MLJ UnitTest2 " + DateTime.Now.ToString("yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture)
};
var id2 = orgAdminUIService.Create(acc2);
var contact = new Contact()
{
FirstName = "Jesper",
LastName = "Test"
};
contact.ParentCustomerId = new EntityReference(Account.EntityLogicalName, id2);
var cid = orgAdminUIService.Create(contact);
var acc1a = new Account(id1)
{
ParentAccountId = new EntityReference(Account.EntityLogicalName, id2)
};
orgAdminUIService.Update(acc1a);
var retrieved = orgAdminUIService.Retrieve(Account.EntityLogicalName, id1,
new ColumnSet("accountid")).ToEntity <Account>();
context.Attach(retrieved);
context.Load(retrieved, x => x.ParentAccountId);
var retrieved2 = orgAdminUIService.Retrieve(Account.EntityLogicalName, id2,
new ColumnSet("accountid")).ToEntity <Account>();
context.Attach(retrieved2);
context.LoadEnumeration(retrieved, x => x.Referencedaccount_parent_account);
var testEnumeration1 = context.LoadEnumeration(retrieved, x => x.Referencedaccount_parent_account);
var testEnumeration2 = context.LoadEnumeration(retrieved2, x => x.Referencedaccount_parent_account);
var testRelated1 = context.Load(retrieved, x => x.Referencingaccount_parent_account);
var testRelated2 = context.Load(retrieved2, x => x.Referencingaccount_parent_account);
var accountsWithContacts =
context.AccountSet
.Join <Account, Contact, Guid, object>(context.ContactSet, acc => acc.Id, c => c.ParentCustomerId.Id, (acc, c) => new { acc, c })
.FirstOrDefault();
Assert.True(testEnumeration1.Count() == 0);
Assert.True(testEnumeration2.Count() > 0);
Assert.NotNull(testRelated1);
Assert.Null(testRelated2);
Assert.True(testRelated1.RelatedEntities.Count() > 0);
Assert.True(testRelated1.RelatedEntities.Values.First().Entities.Count() > 0);
Assert.Equal(testEnumeration2.Count(), testRelated1.RelatedEntities.Values.First().Entities.Count());
Assert.Equal(retrieved.ParentAccountId.Id, id2);
Assert.Equal(retrieved2.Referencedaccount_parent_account?.FirstOrDefault()?.Id, id1);
}
}
private void OnSessionPropertyChanged(object sender, Xrm.ComponentModel.PropertyChangedEventArgs e)
{
if ((e.PropertyName == "dev1_starttime") || (e.PropertyName == "dev1_endtime"))
{
OnStartEndDateChanged(sender);
}
else if (e.PropertyName == "dev1_duration")
{
OnDurationChanged(sender);
}
// TODO: This should really provide the row that is changing
Refresh();
}
public void TestExecuteMultipleAll()
{
var account1 = new Account {
Name = "Account 1"
};
var account2 = new Account {
Name = "Account 2"
};
var account3 = new Account {
Name = "Account 3"
};
var account4 = new Account {
Name = "Account 4"
};
var account5 = new Account {
Name = "Account 5"
};
using (var context = new Xrm(orgAdminUIService))
{
#region Execute Multiple with Results
// Create an ExecuteMultipleRequest object.
ExecuteMultipleRequest requestWithResults = 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()
};
// Create several (local, in memory) entities in a collection.
EntityCollection create = new EntityCollection()
{
EntityName = Account.EntityLogicalName,
Entities =
{
account1,
account2,
account3,
account4,
account5
}
};
// Add a CreateRequest for each entity to the request collection.
foreach (var entity in create.Entities)
{
CreateRequest createRequest = new CreateRequest {
Target = entity
};
requestWithResults.Requests.Add(createRequest);
}
// Execute all the requests in the request collection using a single web method call.
ExecuteMultipleResponse responseWithResults =
(ExecuteMultipleResponse)orgAdminUIService.Execute(requestWithResults);
Assert.AreEqual(5, responseWithResults.Responses.Count);
// Display the results returned in the responses.
foreach (var responseItem in responseWithResults.Responses)
{
var response = responseItem.Response;
Assert.IsNotNull(response);
Assert.IsNull(responseItem.Fault);
Assert.IsInstanceOfType(response, typeof(CreateResponse));
// make this Test work, values are the same, but any is not allowed for some reason
//Assert.IsTrue(context.AccountSet.Any(x => x.Id.Equals(response.Results["id"])));
}
#endregion Execute Multiple with Results
#region Execute Multiple with No Results
ExecuteMultipleRequest requestWithNoResults = new ExecuteMultipleRequest()
{
// Set the execution behavior to not continue after the first error is received
// and to not return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = false
},
Requests = new OrganizationRequestCollection()
};
// Update the entities that were previously created.
EntityCollection update = new EntityCollection()
{
EntityName = Account.EntityLogicalName,
Entities =
{
new Account {
Name = "Updated Account 1", Id = account1.Id
},
new Account {
Name = "Updated Account 2", Id = account2.Id
},
new Account {
Name = "Updated Account 3", Id = account3.Id
},
new Account {
Name = "Updated Account 4", Id = account4.Id
},
new Account {
Name = "Updated Account 5", Id = account5.Id
},
}
};
foreach (var entity in update.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity
};
requestWithNoResults.Requests.Add(updateRequest);
}
ExecuteMultipleResponse responseWithNoResults =
(ExecuteMultipleResponse)orgAdminUIService.Execute(requestWithNoResults);
Assert.AreEqual(0, responseWithNoResults.Responses.Count);
#endregion Execute Multiple with No Results
#region Execute Multiple with Continue On Error
ExecuteMultipleRequest requestWithContinueOnError = new ExecuteMultipleRequest()
{
// Set the execution behavior to continue on an error and not return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = false
},
Requests = new OrganizationRequestCollection()
};
// Update the entities but introduce some bad attribute values so we get errors.
EntityCollection updateWithErrors = new EntityCollection()
{
EntityName = Account.EntityLogicalName,
Entities =
{
new Account {
Name = "Updated Account 1", Id = account1.Id
},
new Account {
Name = "Updated Account 2", Id = new Guid()
},
new Account {
Name = "Updated Account 3", Id = account3.Id
},
new Account {
Name = "Updated Account 4", Id = new Guid()
},
new Account {
Name = "Updated Account 5", Id = account5.Id
},
}
};
foreach (var entity in updateWithErrors.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity
};
requestWithContinueOnError.Requests.Add(updateRequest);
}
ExecuteMultipleResponse responseWithContinueOnError =
(ExecuteMultipleResponse)orgAdminUIService.Execute(requestWithContinueOnError);
Assert.AreEqual(2, responseWithContinueOnError.Responses.Count);
Assert.IsTrue(responseWithContinueOnError.Responses.All(
x => x.Response == null && x.Fault != null && x.Fault.Message != null));
#endregion Execute Multiple with Continue On Error
#region Execute Multiple with Stop On Error
ExecuteMultipleRequest requestWithStopOnError = new ExecuteMultipleRequest()
{
// Set the execution behavior to continue on an error and not return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = false
},
Requests = new OrganizationRequestCollection()
};
foreach (var entity in updateWithErrors.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity
};
requestWithStopOnError.Requests.Add(updateRequest);
}
ExecuteMultipleResponse responseWithStopOnError =
(ExecuteMultipleResponse)orgAdminUIService.Execute(requestWithStopOnError);
Assert.AreEqual(1, responseWithStopOnError.Responses.Count);
Assert.IsTrue(responseWithStopOnError.Responses.All(
x => x.Response == null && x.Fault != null && x.Fault.Message != null));
#endregion Execute Multiple with Stop On Error
#region Execute Multiple with Continue On Error And Returns
ExecuteMultipleRequest requestWithContinueOnErrorAndReturns = new ExecuteMultipleRequest()
{
// Set the execution behavior to continue on an error and not return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = true,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
foreach (var entity in updateWithErrors.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity
};
requestWithContinueOnErrorAndReturns.Requests.Add(updateRequest);
}
ExecuteMultipleResponse responseWithContinueOnErrorAndReturns =
(ExecuteMultipleResponse)orgAdminUIService.Execute(requestWithContinueOnErrorAndReturns);
Assert.AreEqual(5, responseWithContinueOnErrorAndReturns.Responses.Count);
Assert.AreEqual(2, responseWithContinueOnErrorAndReturns.Responses.Count(
x => x.Response == null && x.Fault != null && x.Fault.Message != null));
Assert.AreEqual(3, responseWithContinueOnErrorAndReturns.Responses.Count(
x => x.Response != null && x.Fault == null));
#endregion Execute Multiple with Continue On Error And Returns
#region Execute Multiple with Stop On Error And Returns
ExecuteMultipleRequest requestWithStopOnErrorAndReturns = new ExecuteMultipleRequest()
{
// Set the execution behavior to continue on an error and not return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
foreach (var entity in updateWithErrors.Entities)
{
UpdateRequest updateRequest = new UpdateRequest {
Target = entity
};
requestWithStopOnErrorAndReturns.Requests.Add(updateRequest);
}
ExecuteMultipleResponse responseWithStopOnErrorAndReturns =
(ExecuteMultipleResponse)orgAdminUIService.Execute(requestWithStopOnErrorAndReturns);
Assert.AreEqual(2, responseWithStopOnErrorAndReturns.Responses.Count);
Assert.AreEqual(1, responseWithStopOnErrorAndReturns.Responses.Count(
x => x.Response == null && x.Fault != null && x.Fault.Message != null));
Assert.AreEqual(1, responseWithStopOnErrorAndReturns.Responses.Count(
x => x.Response != null && x.Fault == null));
#endregion Execute Multiple with Stop On Error And Returns
}
}
public void TestRetrieveRelatedEntities()
{
using (var context = new Xrm(orgAdminUIService)) {
var accountName = "Litware, Inc.";
var _accountId = orgAdminUIService.Create(
new Account {
Name = accountName,
Address1_StateOrProvince = "Colorado"
});
// Create the two contacts.
var _contact1Id = orgAdminUIService.Create(
new Contact()
{
FirstName = "Ben",
LastName = "Andrews",
EMailAddress1 = "*****@*****.**",
Address1_City = "Redmond",
Address1_StateOrProvince = "WA",
Address1_Telephone1 = "(206)555-5555",
ParentCustomerId = new EntityReference {
Id = _accountId,
LogicalName = Account.EntityLogicalName
}
});
var _contact2Id = orgAdminUIService.Create(
new Contact()
{
FirstName = "Alan",
LastName = "Wilcox",
EMailAddress1 = "*****@*****.**",
Address1_City = "Bellevue",
Address1_StateOrProvince = "WA",
Address1_Telephone1 = "(425)555-5555",
ParentCustomerId = new EntityReference {
Id = _accountId,
LogicalName = Account.EntityLogicalName
}
});
//create the query expression object
QueryExpression query = new QueryExpression();
//Query on reated entity records
query.EntityName = "contact";
//Retrieve the all attributes of the related record
query.ColumnSet = new ColumnSet(true);
//create the relationship object
Relationship relationship = new Relationship();
//add the condition where you can retrieve only the account related active contacts
query.Criteria = new FilterExpression();
query.Criteria.AddCondition(new ConditionExpression("address1_city", ConditionOperator.Equal, "Bellevue"));
// name of relationship between account & contact
relationship.SchemaName = "contact_customer_accounts";
//create relationshipQueryCollection Object
RelationshipQueryCollection relatedEntity = new RelationshipQueryCollection();
//Add the your relation and query to the RelationshipQueryCollection
relatedEntity.Add(relationship, query);
//create the retrieve request object
RetrieveRequest request = new RetrieveRequest();
//add the relatedentities query
request.RelatedEntitiesQuery = relatedEntity;
//set column to and the condition for the account
request.ColumnSet = new ColumnSet("accountid");
request.Target = new EntityReference {
Id = _accountId, LogicalName = "account"
};
//execute the request
RetrieveResponse response = (RetrieveResponse)orgAdminUIService.Execute(request);
Assert.AreEqual(1, response.Entity.RelatedEntities.Count);
var collection = response.Entity.RelatedEntities.Values.First();
Assert.AreEqual(1, collection.Entities.Count);
var entity = collection.Entities.First();
Assert.IsTrue(entity.Attributes.ContainsKey("firstname"));
Assert.AreEqual("Alan", entity.Attributes["firstname"]);
}
}
public void TestBasesGetUpdated()
{
using (var context = new Xrm(orgAdminUIService))
{
var currency = new TransactionCurrency()
{
ExchangeRate = 0.5m,
CurrencyPrecision = 2
};
currency.Id = orgAdminUIService.Create(currency);
// test currency gets set
var bus = new dg_bus
{
TransactionCurrencyId = currency.ToEntityReference()
};
bus.Id = orgAdminUIService.Create(bus);
var retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.Equal(bus.TransactionCurrencyId, retrieved.TransactionCurrencyId);
// test base value gets updated
bus.dg_Ticketprice = 100m;
orgAdminUIService.Update(bus);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.Equal(Math.Round(bus.dg_Ticketprice.Value / currency.ExchangeRate.Value, currency.CurrencyPrecision.Value), retrieved.dg_ticketprice_Base);
// test currency doesn't update before record gets updated
var oldExchangeRate = currency.ExchangeRate;
currency.ExchangeRate = 0.7m;
orgAdminUIService.Update(currency);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.Equal(Math.Round(bus.dg_Ticketprice.Value / oldExchangeRate.Value, currency.CurrencyPrecision.Value), retrieved.dg_ticketprice_Base);
// test base value gets updated when record field value changes
bus.dg_Ticketprice = 120m;
orgAdminUIService.Update(bus);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.Equal(Math.Round(bus.dg_Ticketprice.Value / currency.ExchangeRate.Value, currency.CurrencyPrecision.Value), retrieved.dg_ticketprice_Base);
// test base value gets updated when transactioncurrencyid changes
var newCurrency = new TransactionCurrency
{
ExchangeRate = 1m,
CurrencyPrecision = 3
};
newCurrency.Id = orgAdminUIService.Create(newCurrency);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.Equal(Math.Round(bus.dg_Ticketprice.Value / currency.ExchangeRate.Value, currency.CurrencyPrecision.Value), retrieved.dg_ticketprice_Base);
bus.TransactionCurrencyId = newCurrency.ToEntityReference();
orgAdminUIService.Update(bus);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.Equal(Math.Round(bus.dg_Ticketprice.Value / newCurrency.ExchangeRate.Value, newCurrency.CurrencyPrecision.Value), retrieved.dg_ticketprice_Base);
// test base value gets updated when state of record changes
oldExchangeRate = newCurrency.ExchangeRate;
newCurrency.ExchangeRate = 0.3m;
orgAdminUIService.Update(newCurrency);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.Equal(Math.Round(bus.dg_Ticketprice.Value / oldExchangeRate.Value, newCurrency.CurrencyPrecision.Value), retrieved.dg_ticketprice_Base);
bus.SetState(orgAdminUIService, dg_busState.Inactive);
retrieved = orgAdminUIService.Retrieve(dg_bus.EntityLogicalName, bus.Id, new ColumnSet(true)) as dg_bus;
Assert.Equal(Math.Round(bus.dg_Ticketprice.Value / newCurrency.ExchangeRate.Value, newCurrency.CurrencyPrecision.Value), retrieved.dg_ticketprice_Base);
}
}
public static ProxyConnection SingleConvertToProxyConnection(Xrm.Connection connection, XrmServiceContext context)
{
ProxyConnection pc = null;
if (connection != null)
{
pc = new ProxyConnection();
pc.Name = connection.Name;
pc.ID = connection.Id;
pc.Role = connection.Record2RoleId != null ? connection.Record2RoleId.Name : string.Empty;
pc.OpportunityId = connection.Record1Id != null ? connection.Record1Id.Id.ToString() : Guid.Empty.ToString();
if ((connection.Record2Id != null) && (!string.IsNullOrEmpty(connection.Record2Id.LogicalName)))
{
if (connection.Record2Id.LogicalName.Equals("contact", StringComparison.InvariantCultureIgnoreCase))
{
//using (Xrm.XrmServiceContext context = new XrmServiceContext("Xrm"))
//{
var contact = context.ContactSet.Where(c => c.Id == connection.Record2Id.Id).FirstOrDefault();
if (contact != null)
{
pc.Fullname = contact.FullName;
pc.JobTitle = contact.JobTitle;
pc.AccountName = contact.contact_customer_accounts != null ? contact.contact_customer_accounts.Name : string.Empty;
pc.Email = contact.EMailAddress1;
pc.BusinessPhone = contact.Telephone1;
pc.MobilePhone = contact.MobilePhone;
pc.Fax = contact.Fax;
pc.PreferedMethodofContact = EnsureValueFromOptionSet(contact, "preferredcontactmethodcode"); // contact.PreferredContactMethodCode
pc.Address1_Street1 = contact.Address1_Line1;
pc.Address1_Street2 = contact.Address1_Line2;
pc.Address1_Street3 = contact.Address1_Line3;
pc.Address1_City = contact.Address1_City;
pc.Address1_StateProvince = contact.Address1_StateOrProvince;
pc.Address1_ZipCode = contact.Address1_PostalCode;
pc.Address1_CountryRegion = contact.Address1_Country;
}
//}
}
}
}
return pc;
}
protected override void Execute(CodeActivityContext executionContext)
{
// Create the tracing service
ITracingService tracingService = executionContext.GetExtension <ITracingService>();
if (tracingService == null)
{
throw new InvalidPluginExecutionException("Failed to retrieve tracing service.");
}
tracingService.Trace("Entered AddResourceProductToTheBooking.Execute(), Activity Instance Id: {0}, Workflow Instance Id: {1}",
executionContext.ActivityInstanceId,
executionContext.WorkflowInstanceId);
// Create the context
IWorkflowContext context = executionContext.GetExtension <IWorkflowContext>();
if (context == null)
{
throw new InvalidPluginExecutionException("Failed to retrieve workflow context.");
}
tracingService.Trace("AddResourceProductToTheBooking.Execute(), Correlation Id: {0}, Initiating User: {1}",
context.CorrelationId,
context.InitiatingUserId);
IOrganizationServiceFactory serviceFactory = executionContext.GetExtension <IOrganizationServiceFactory>();
IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);
Xrm xrm = new Xrm(service);
tracingService.Trace("Creating AddResourceProductToTheBooking...");
try
{
var resId = context.PrimaryEntityId;
tracingService.Trace("1 - " + resId.ToString());
var res = xrm.BookableResourceBookingSet.FirstOrDefault(b => b.BookableResourceBookingId.Value == resId);
tracingService.Trace("2 - " + res.Name);
var booking = xrm.dyna_bookingSet.FirstOrDefault(b => b.ActivityId.Value == res.new_dyna_booking.Id);
tracingService.Trace("3 - " + booking.Subject);
if (res != null)
{
tracingService.Trace("4 - has res ");
var eq = xrm.BookableResourceSet.FirstOrDefault(f => f.BookableResourceId.Value == res.Resource.Id);
if (eq.dyna_ProductId != null)
{
tracingService.Trace("5 - has product ");
var pro = xrm.ProductSet.FirstOrDefault(p => p.ProductId.Value == eq.dyna_ProductId.Id);
tracingService.Trace("6 - got product ");
double antal = 1;
if (booking.dyna_bookingtype.Value == 378080003)
{
tracingService.Trace("6.a - dyna_bookingtype ");
antal = 1; //Math.Round(double.Parse((booking.ScheduledDurationMinutes.Value / 60 / 24).ToString("F2")), MidpointRounding.AwayFromZero);
}
tracingService.Trace("7 - adding dyna_bookingproductline ");
dyna_bookingproductline bpl = new dyna_bookingproductline();
bpl.dyna_AccommodationTypeId = eq.dyna_AccommodationTypeId;
bpl.dyna_count = int.Parse(antal.ToString());
// bpl.dyna_LokaleType = new OptionSetValue(378080000);
bpl.dyna_price = pro.Price;
bpl.dyna_useprice = pro.Price;
bpl.dyna_productid = pro.ToEntityReference();
bpl.dyna_name = pro.Name;
bpl.dyna_bookingid = booking.dyna_parentbookingid != null ? booking.dyna_parentbookingid : booking.ToEntityReference();
tracingService.Trace("8 - finish dyna_bookingproductline ");
service.Create(bpl);
}
}
tracingService.Trace("Done.");
}
catch (FaultException <OrganizationServiceFault> e)
{
tracingService.Trace("Exception: {0} - {1}", e.ToString(), e.StackTrace);
// Handle the exception.
throw;
}
tracingService.Trace("Exiting AddResourceProductToTheBooking.Execute(), Correlation Id: {0}", context.CorrelationId);
}
public void TestActionParts()
{
using (var context = new Xrm(orgAdminUIService))
{
var stringInput = "A string";
var datetimeInput = DateTime.Now;
var boolInput = true;
var decimalInput = 12.3m;
var floatInput = 412.2f;
var intInput = 12;
var moneyInput = new Money(123.7m);
var pickListInput = new OptionSetValue(3);
var entity = new Contact();
entity.Id = orgAdminUIService.Create(entity);
var req = new OrganizationRequest("Full action");
req["StringInput"] = stringInput;
req["Target"] = entity.ToEntityReference();
var resp = orgAdminUIService.Execute(req);
Assert.True(resp.Results.ContainsKey("Output"));
var output = resp["Output"] as string;
Assert.Equal(stringInput, output);
req = new OrganizationRequest("Full action");
req["DateTimeInput"] = datetimeInput;
req["Target"] = entity.ToEntityReference();
resp = orgAdminUIService.Execute(req);
Assert.True(resp.Results.ContainsKey("Output"));
output = resp["Output"] as string;
Assert.Equal(datetimeInput.ToString(), output);
req = new OrganizationRequest("Full action");
req["BoolInput"] = boolInput;
req["Target"] = entity.ToEntityReference();
resp = orgAdminUIService.Execute(req);
Assert.True(resp.Results.ContainsKey("Output"));
output = resp["Output"] as string;
Assert.Equal(boolInput.ToString(), output);
req = new OrganizationRequest("Full action");
req["DecimalInput"] = decimalInput;
req["Target"] = entity.ToEntityReference();
resp = orgAdminUIService.Execute(req);
Assert.True(resp.Results.ContainsKey("Output"));
output = resp["Output"] as string;
Assert.Equal(decimalInput.ToString(), output);
req = new OrganizationRequest("Full action");
req["FloatInput"] = floatInput;
req["Target"] = entity.ToEntityReference();
resp = orgAdminUIService.Execute(req);
Assert.True(resp.Results.ContainsKey("Output"));
output = resp["Output"] as string;
Assert.Equal(floatInput.ToString(), output);
req = new OrganizationRequest("Full action");
req["IntegerInput"] = intInput;
req["Target"] = entity.ToEntityReference();
resp = orgAdminUIService.Execute(req);
Assert.True(resp.Results.ContainsKey("Output"));
output = resp["Output"] as string;
Assert.Equal(intInput.ToString(), output);
req = new OrganizationRequest("Full action");
req["PicklistInput"] = pickListInput;
req["Target"] = entity.ToEntityReference();
resp = orgAdminUIService.Execute(req);
Assert.True(resp.Results.ContainsKey("Output"));
output = resp["Output"] as string;
Assert.Equal(pickListInput.ToString(), output);
}
}
public void TestExecuteMultipleWithResults()
{
using (var context = new Xrm(orgAdminUIService)) {
// Create an ExecuteMultipleRequest object.
ExecuteMultipleRequest requestWithResults = 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()
};
// Create several (local, in memory) entities in a collection.
EntityCollection create = new EntityCollection()
{
EntityName = Account.EntityLogicalName,
Entities =
{
new Account {
Name = "Account 1"
},
new Account {
Name = "Account 2"
},
new Account {
Name = "Account 3"
},
new Account {
Name = "Account 4"
},
new Account {
Name = "Account 5"
}
}
};
// Add a CreateRequest for each entity to the request collection.
foreach (var entity in create.Entities)
{
CreateRequest createRequest = new CreateRequest {
Target = entity
};
requestWithResults.Requests.Add(createRequest);
}
// Execute all the requests in the request collection using a single web method call.
ExecuteMultipleResponse responseWithResults =
(ExecuteMultipleResponse)orgAdminUIService.Execute(requestWithResults);
Assert.AreEqual(5, responseWithResults.Responses.Count);
// Display the results returned in the responses.
foreach (var responseItem in responseWithResults.Responses)
{
var response = responseItem.Response;
Assert.IsNotNull(response);
Assert.IsNull(responseItem.Fault);
Assert.IsInstanceOfType(response, typeof(CreateResponse));
// make this Test work, values are the same, but any is not allowed for some reason
//Assert.IsTrue(context.AccountSet.Any(x => x.Id.Equals(response.Results["id"])));
}
}
}
