public void CommitAddedObject()
{
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.PersistAddedEntityBase = (contact) =>
{
var sdkContact = new Contact();
sdkContact.ContactId = contact.Id;
sdkContact.FirstName = "test";
var createRequest = new CreateRequest()
{
Target = sdkContact
};
crmUnitOfWork.Requests.Add(createRequest);
};
contactRepository.Add(new Xrm.Domain.Contact.Contact());
crmUnitOfWork.Commit();
Assert.AreEqual(exptectedCallCount, callCount);
}
/// <summary>
/// To create record
/// </summary>
/// <param name="entity"></param>
/// <param name="service"></param>
public static void CreateRecord(Entity entity, IOrganizationService service)
{
if (entity == null)
{
return;
}
if (service == null)
{
return;
}
var createRequest = new CreateRequest {
Target = entity
};
service.Execute(createRequest);
}
public AccountResponse Create(CreateRequest model)
{
var currentAccount = accountRepository.GetAll().SingleOrDefault(x => x.Email == model.Email);
if (currentAccount != null)
{
throw new Exception($"Email {model.Email} has been registered");
}
var account = mapper.Map <Account>(model);
account.Created = DateTime.UtcNow;
account.Verified = DateTime.UtcNow;
account.PasswordHash = BC.HashPassword(model.Password);
accountRepository.Add(account);
return(mapper.Map <AccountResponse>(account));
}
public override async Task <CreateResponse> Create(CreateRequest request, ServerCallContext context)
{
//TODO: change to BookingExpireNotification model
//var dto = new CreateNotification
//{
// TourId = request.TourId,
// TourName = request.TourName,
// BookingId = request.BookingId,
// BookingName = request.BookingName,
// BookingNotes = request.BookingNotes,
// ExpireDate = request.ExpireDate.ToDateTime(),
// UserIds = request.AssignedUserIds
//};
//var result = await _notificationService.CreateNotification(dto);
//return new CreateResponse() { Succeed = result };
throw new NotImplementedException();
}
/// <summary>
/// Create user
/// </summary>
public static DetailsResponse CreateUser()
{
var createRequest = new CreateRequest(
email: "*****@*****.**",
externalAccountData: "SampleData",
fieldValues: new List <FieldValueModelBase>
{
new TextFieldValueModel("companyName", "Sample Company Name")
},
firstName: "John",
lastName: "Doe",
password: "******",
thirdPartyUniqueId: "31122222"
);
return(ApiClient.CreateUser(createRequest));
}
public void AddQuestion([FromBody] CreateRequest Request)
{
Validation(Request);
var que = new Question()
{
Text = Request.Question
};
var Answers = new List <Answer>();
var ans = Request.Answers.Select(x => Mapper.ToModel(x));
Answers.AddRange(ans);
que.AnswersId = new List <Answer>();
que.AnswersId.AddRange(Answers);
db.Questions.Add(que);
db.SaveChanges();
}
public async Task <ActionResult <BoolResult> > Create([FromBody] CreateRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId, Types.SitePermissions.CreateSpecials))
{
return(Unauthorized());
}
foreach (var specialId in request.SpecialIds)
{
await _createManager.CreateSpecialAsync(request.SiteId, specialId);
}
return(new BoolResult
{
Value = true
});
}
/// <summary>
/// Begins the send.
/// </summary>
void IAlertMessage.BeginSend()
{
// Check File
//if (this.Files.Count > 0)
//{
// // Create Single EML
// this.MessageEntity.MessageContext = CreateMessageContent();
//}
// Create Message
CreateRequest request = new CreateRequest(this.MessageEntity);
request.Parameters.Add(OutgoingMessageQueuePlugin.AddToQueue, true);
request.Parameters.Add(OutgoingMessageQueuePlugin.SourceName, OutgoingEmailServiceType.AlertService.ToString());
BusinessManager.Execute(request);
}
public byte[] Create(byte[] requestData)
{
CreateRequest request = (CreateRequest)Deserialize(requestData);
DataPortal portal = new DataPortal();
object result;
try
{
result = portal.Create(request.ObjectType, request.Criteria, request.Context);
}
catch (Exception ex)
{
result = ex;
}
return(Serialize(result));
}
public IResponseData <string> CreateRequest(CreateRequest request)
{
IResponseData <string> response = new ResponseData <string>();
try
{
IRequestService service = IoC.Container.Resolve <IRequestService>();
service.CreateRequest(request);
}
catch (ValidationException ex)
{
response.SetErrors(ex.Errors);
response.SetStatus(HttpStatusCode.PreconditionFailed);
}
return(response);
}
private async Task CreateContentChildrenTemplateAsync(CreateRequest request)
{
var relatedFileNameList = await _templateRepository.GetRelatedFileNamesAsync(request.SiteId, TemplateType.ContentTemplate);
var templateNameList = await _templateRepository.GetTemplateNamesAsync(request.SiteId, TemplateType.ContentTemplate);
foreach (var channelId in request.ChannelIds)
{
var nodeInfo = await _channelRepository.GetAsync(channelId);
var templateInfo = new Template
{
Id = 0,
SiteId = request.SiteId,
TemplateName = nodeInfo.ChannelName + "_下级",
TemplateType = TemplateType.ContentTemplate,
RelatedFileName = "T_" + nodeInfo.ChannelName + "_下级.html",
CreatedFileFullName = "index.html",
CreatedFileExtName = ".html",
DefaultTemplate = false
};
if (ListUtils.ContainsIgnoreCase(relatedFileNameList, templateInfo.RelatedFileName))
{
continue;
}
if (templateNameList.Contains(templateInfo.TemplateName))
{
continue;
}
var insertedTemplateId = await _templateRepository.InsertAsync(templateInfo);
var childChannelIdList = await _channelRepository.GetChannelIdsAsync(request.SiteId, channelId, ScopeType.Descendant);
foreach (var childChannelId in childChannelIdList)
{
var childChannelInfo = await _channelRepository.GetAsync(childChannelId);
childChannelInfo.ContentTemplateId = insertedTemplateId;
await _channelRepository.UpdateContentTemplateIdAsync(childChannelInfo);
//TemplateManager.UpdateContentTemplateId(SiteId, childChannelId, insertedTemplateId);
//DataProvider.BackgroundNodeDAO.UpdateContentTemplateID(childChannelId, insertedTemplateID);
}
}
}
public async Task Handle_DefaultWithoutResponse_CreatesUser()
{
var request = new CreateRequest <User, UserDto>(new UserDto
{
Name = "TestUser"
});
var response = await Mediator.HandleAsync(request);
Assert.IsFalse(response.HasErrors);
Assert.AreEqual(1, Context.Set <User>().Count());
var user = Context.Set <User>().FirstOrDefault();
Assert.IsNotNull(user);
Assert.AreEqual("TestUser", user.Name);
}
public AccountResponse Create(CreateRequest model)
{
// validate
if (context.Accounts.Any(x => x.Email == model.Email))
{
throw new Exception($"Email '{model.Email}' is already registered");
}
// map model to new account object
var account = model.ToAccount();
// save account
context.Accounts.Add(account);
context.SaveChanges();
return(new AccountResponse(account));
}
public override Task <Empty> Create(CreateRequest request, ServerCallContext context)
{
Program.WriteLine("SdkDriverImpl.Create", request);
var listener = new Listener();
listener.Event += (s, e) => OnEvent(e);
var connector = sdk.CloverConnectorFactory.CreateUsbConnector("RAID", "POS", "Register1", false);
connector.AddCloverConnectorListener(listener);
Program.Connector = connector;
Program.Listener = listener;
return(Task.FromResult(new Empty()));
}
public async Task <ActionResult <BoolResult> > Create([FromBody] CreateRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.CreateFiles))
{
return(Unauthorized());
}
foreach (var templateId in request.TemplateIds)
{
await _createManager.CreateFileAsync(request.SiteId, templateId);
}
return(new BoolResult
{
Value = true
});
}
public void CreateGreeting_Async()
{
RestClient client = new RestClient(urlPrefix);
GreetingBuilder greetingBuilder = new GreetingBuilder();
greetingBuilder.id = 0; // Dummy value
greetingBuilder.message = "Create me!";
greetingBuilder.tone = new Tone(Tone.Symbol.FRIENDLY);
Greeting input = greetingBuilder.Build();
CreateRequestBuilder <int, Greeting> requestBuilder = new CreateRequestBuilder <int, Greeting>("/basicCollection");
requestBuilder.input = input;
CreateRequest <int, Greeting> request = requestBuilder.Build();
AutoResetEvent blocker = new AutoResetEvent(false);
CreateResponse <int, Greeting> createResponse = null;
ClientErrorResponse errorResponse = null;
RestliCallback <CreateResponse <int, Greeting> > .SuccessHandler successHandler = delegate(CreateResponse <int, Greeting> response)
{
createResponse = response;
blocker.Set();
};
RestliCallback <CreateResponse <int, Greeting> > .ErrorHandler errorHandler = delegate(ClientErrorResponse response)
{
errorResponse = response;
blocker.Set();
};
RestliCallback <CreateResponse <int, Greeting> > callback = new RestliCallback <CreateResponse <int, Greeting> >(successHandler, errorHandler);
client.RestRequestAsync(request, callback);
blocker.WaitOne(asyncTimeoutMillis);
Assert.IsNull(errorResponse);
Assert.AreEqual(RestConstants.httpStatusCreated, createResponse.status);
Assert.AreEqual(123, createResponse.key);
CollectionAssert.AreEqual(new List <string>()
{
"/basicCollection/123"
}, createResponse.headers[RestConstants.kHeaderLocation].ToList());
}
/// <summary>
/// Creates a new instance of Core
/// </summary>
/// <param name="Settings"></param>
/// <param name="metadata"></param>
/// <param name="SecurityRoles"></param>
/// <param name="Workflows"></param>
public Core(XrmMockupSettings Settings, MetadataSkeleton metadata, List <Entity> Workflows, List <SecurityRole> SecurityRoles)
{
this.TimeOffset = new TimeSpan();
this.settings = Settings;
this.metadata = metadata;
baseCurrency = metadata.BaseOrganization.GetAttributeValue <EntityReference>("basecurrencyid");
baseCurrencyPrecision = metadata.BaseOrganization.GetAttributeValue <int>("pricingdecimalprecision");
this.db = new XrmDb(metadata.EntityMetadata, GetOnlineProxy());
this.snapshots = new Dictionary <string, Snapshot>();
this.security = new Security(this, metadata, SecurityRoles, this.db);
this.ServiceFactory = new MockupServiceProviderAndFactory(this);
//add the additional plugin settings to the meta data
if (settings.IPluginMetadata != null)
{
metadata.Plugins.AddRange(Settings.IPluginMetadata);
}
this.pluginManager = new PluginManager(Settings.BasePluginTypes, metadata.EntityMetadata, metadata.Plugins);
this.workflowManager = new WorkflowManager(Settings.CodeActivityInstanceTypes, Settings.IncludeAllWorkflows, Workflows, metadata.EntityMetadata);
this.systemAttributeNames = new List <string>()
{
"createdon", "createdby", "modifiedon", "modifiedby"
};
this.RequestHandlers = GetRequestHandlers(db);
InitializeDB();
this.security.InitializeSecurityRoles(db);
//persist the access team templates as they livein the db as records.
if (metadata.AccessTeamTemplates != null)
{
foreach (var att in metadata.AccessTeamTemplates)
{
if (!db.HasRow(att.ToEntityReference()))
{
var create = new CreateRequest();
create.Target = att;
this.Execute(create, AdminUserRef);
}
}
}
}
public async Task<ActionResult<List<int>>> Create([FromBody] CreateRequest request)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.Channels))
{
return Unauthorized();
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (site == null) return NotFound();
var expendedChannelIds = new List<int>
{
request.SiteId
};
foreach (var channelId in request.ChannelIds)
{
var channel = await _channelRepository.GetAsync(channelId);
if (!expendedChannelIds.Contains(channel.ParentId))
{
expendedChannelIds.Add(channel.ParentId);
}
await _createManager.CreateChannelAsync(request.SiteId, channelId);
if (request.IsCreateContents)
{
await _createManager.CreateAllContentAsync(request.SiteId, channelId);
}
if (request.IsIncludeChildren)
{
var channelIds = await _channelRepository.GetChannelIdsAsync(request.SiteId, channelId, ScopeType.Descendant);
foreach (var childChannelId in channelIds)
{
await _createManager.CreateChannelAsync(request.SiteId, childChannelId);
if (request.IsCreateContents)
{
await _createManager.CreateAllContentAsync(request.SiteId, channelId);
}
}
}
}
return expendedChannelIds;
}
public override Task <CreateResponse> Create(CreateRequest request,
ServerCallContext context)
{
// We only support creating one SBPlatform object, fail if there is an attempt to
// create more.
if (sbPlatform != null)
{
ErrorUtils.ThrowError(StatusCode.FailedPrecondition,
"Creating multiple SBPlatform objects is not supported.");
}
sbPlatform = sbPlatformFactory.Create(request.PlatformName);
if (sbPlatform == null)
{
ErrorUtils.ThrowError(StatusCode.Internal, "Could not create SBPlatform.");
}
return(Task.FromResult(new CreateResponse()));
}
public void ShouldSerializeCustomData()
{
//Arrange
var dataJson = "{\"property\":\"value\"}";
var obj = new CreateRequest
{
Content = dataJson
};
//Act
var json = JsonConvert.SerializeObject(obj);
_output.WriteLine("Json: " + json);
//Assert
Assert.NotNull(json);
Assert.Equal("{\"requestId\":null,\"procRouting\":null,\"callbackRouting\":null,\"content\":" + dataJson + "}", json);
}
public override Task <CreateReply> CreatePlayer(CreateRequest request, ServerCallContext context)
{
string status;
if (_playerService.CreatePlayer(request.Nick, _httpContext.GetUsername()).Id != null)
{
status = "ok";
}
else
{
status = "nick_exist";
}
return(Task.FromResult(new CreateReply
{
Status = status ?? "error"
}));
}
public DogImageResponse Create(CreateRequest model)
{
// map model to new DogImage object
var DogImage = _mapper.Map <DogImage>(model);
DogImage.FileName = saveImageToDogImages(model.DogImages);
DogImage.Created = DateTime.UtcNow;
// save dog
_context.DogImages.Add(DogImage);
_context.SaveChanges();
var response = _mapper.Map <DogImageResponse>(DogImage);
//response.DogImage = readDogImagesToIFormFile(DogImage.FileName);
return(response);
}
internal static void CloseOpportunity(Core core, OpportunityState state, OptionSetValue status, Entity opportunityClose, EntityReference userRef)
{
var setStateHandler = core.RequestHandlers.Find(x => x is SetStateRequestHandler);
var req = new SetStateRequest()
{
EntityMoniker = opportunityClose.GetAttributeValue <EntityReference>("opportunityid"),
State = new OptionSetValue((int)state),
Status = status
};
setStateHandler.Execute(req, userRef);
var create = new CreateRequest {
Target = opportunityClose
};
core.Execute(create as OrganizationRequest, userRef);
}
private Guid CreateNewExternalLogin(string userInitials, string abta, Guid bcId, string branchcode, string employeeId, string name)
{
var extLoginEntity = new Entity(EntityName.ExternalLogin);
extLoginEntity.Attributes.Add(Attributes.ExternalLogin.Initials, userInitials);
extLoginEntity.Attributes.Add(Attributes.ExternalLogin.AbtaNumber, abta);
extLoginEntity.Attributes.Add(Attributes.ExternalLogin.BranchCode, branchcode);
extLoginEntity.Attributes.Add(Attributes.ExternalLogin.BudgetCentreId, new EntityReference(EntityName.Store, bcId));
extLoginEntity.Attributes.Add(Attributes.ExternalLogin.OwnerId, new EntityReference(EntityName.User, _myGuid));
extLoginEntity.Attributes.Add(Attributes.ExternalLogin.EmployeeId, employeeId);
extLoginEntity.Attributes.Add(Attributes.ExternalLogin.Name, name);
var createReq = new CreateRequest {
Target = extLoginEntity
};
return(((CreateResponse)_crmService.ExecuteCrmOrganizationRequest(createReq)).id);
}
public IHttpActionResult Create(CreateRequest request)
{
log.Info("Create");
log.Info(JsonConvert.SerializeObject(request));
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CreateResponse results = new CreateResponse();
results.Request = request;
results.Result = null;
results.Id = Guid.Empty;
results.Errors = new List <Dictionary <string, string> >();
Entity newEntity = new Entity(request.Entity);
foreach (KeyValuePair <string, object> field in request.Data)
{
log.Info(field.Key);
newEntity.Attributes[field.Key] = DynHelper.ParsedValue(field.Value, log);
}
try
{
Guid id = connect.Create(newEntity);
results.Result = newEntity;
results.Id = id;
log.Info(JsonConvert.SerializeObject(newEntity));
}
catch (Exception ex)
{
results.Errors.Add(new Dictionary <string, string> {
{ "Message", ex.Message }, { "StackTrace", ex.StackTrace }
});
log.Error(ex.Message);
log.Error(ex.StackTrace);
if (ex.InnerException != null)
{
log.Error(ex.InnerException.Message);
}
}
return(Ok <CreateResponse>(results));
}
public async Task CreateFailTest()
{
var client = await LoginTask()
.ConfigureAwait(false);
await DeleteTestingRecords(client)
.ConfigureAwait(false);
try
{
await Assert.ThrowsAsync <ForceException>(async() =>
{
var result = await client.CreateAsync("Account", new JObject())
.ConfigureAwait(false);
result.Assert();
});
await Assert.ThrowsAsync <ForceException>(async() =>
{
var obj = new AttributedObject($"UnknownObject{Guid.NewGuid():N}");
var request = new CreateRequest {
Records = new List <IAttributedObject> {
obj
}
};
var result = await client.CreateAsync($"UnknownObject{Guid.NewGuid():N}", request)
.ConfigureAwait(false);
result.Assert();
});
await Assert.ThrowsAsync <ForceException>(async() =>
{
var prd2List = Enumerable.Range(1, 4000).Select(_ => new AttributedObject($"UnknownObject{Guid.NewGuid():N}"));
var result = await client.Composite.CreateAsync(prd2List.ToList())
.ConfigureAwait(false);
result.Assert();
});
}
finally
{
await DeleteTestingRecords(client)
.ConfigureAwait(false);
}
}
public async Task <ActionResult <MaterialAudio> > Create([FromQuery] CreateRequest request, [FromForm] IFormFile file)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
Types.SitePermissions.MaterialAudio))
{
return(Unauthorized());
}
var site = await _siteRepository.GetAsync(request.SiteId);
if (file == null)
{
return(this.Error("请选择有效的文件上传"));
}
var fileName = Path.GetFileName(file.FileName);
var fileType = PathUtils.GetExtension(fileName);
if (!_pathManager.IsUploadExtensionAllowed(UploadType.Audio, site, fileType))
{
return(this.Error("文件只能是音频格式，请选择有效的文件上传!"));
}
var materialFileName = PathUtils.GetMaterialFileName(fileName);
var virtualDirectoryPath = PathUtils.GetMaterialVirtualDirectoryPath(UploadType.Audio);
var directoryPath = PathUtils.Combine(_settingsManager.WebRootPath, virtualDirectoryPath);
var filePath = PathUtils.Combine(directoryPath, materialFileName);
await _pathManager.UploadAsync(file, filePath);
var audio = new MaterialAudio
{
GroupId = request.GroupId,
Title = PathUtils.RemoveExtension(fileName),
FileType = fileType.ToUpper().Replace(".", string.Empty),
Url = PageUtils.Combine(virtualDirectoryPath, materialFileName)
};
await _materialAudioRepository.InsertAsync(audio);
return(audio);
}
public async Task CreateAsync_ShouldReturnErrorWhenDenyInAccess()
{
// ARRANGE
var expected = new UmkFile {
Id = 10, Active = true, CreatedAt = new DateTime(2020, 05, 1), FileName = "FileNameNew", FileSize = 1000, FileType = GetTestFileTypes().First(), Name = "NameNew", SubjectId = 1, TermId = 1, UpdatedAt = new DateTime(2020, 05, 2)
};
var mockUmkQuery = new Mock <IUmkFilesQuery>();
mockUmkQuery
.Setup(u => u.Create(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <byte>(), It.IsAny <string>(), It.IsAny <double>(), It.IsAny <string>()))
.ThrowsAsync(new Exception("Mock exception"));
var mockRaspredelenie = new Mock <IRaspredelenieQuery>();
mockRaspredelenie.Setup(r => r.CheckTeacherBySubjectAndTerm(It.IsAny <short>(), It.IsAny <int>(), It.IsAny <byte>()))
.ReturnsAsync(new SPBoolResult {
Result = false
});
var mockContextFactory = SetupContextFactory(mockUmkQuery.Object, null, mockRaspredelenie.Object);
var mockFormFile = new Mock <IFormFile>();
mockFormFile.SetupGet(f => f.ContentType).Returns(GetTestFileTypes().First().Type);
mockFormFile.SetupGet(f => f.FileName).Returns(expected.FileName);
var mockFileService = new Mock <IFileService <UmkFilesConfiguration> >();
mockFileService
.Setup(f => f.UploadAsync(It.IsAny <IFormFile>()))
.ReturnsAsync(expected.FileName);
_sut = new UmkFileService(mockContextFactory.Object, _mapper, mockFileService.Object);
var request = new CreateRequest {
Name = expected.Name, SubjectId = 1, TermId = 1, UmkFile = mockFormFile.Object
};
// ACT
var actual = await _sut.CreateAsync(request);
// ASSERT
Assert.Equal("Отказ в доступе", actual.Error.Message);
}
public void deserialize(InputArchive archive, string tag)
{
archive.startRecord(tag);
MultiHeader h = new MultiHeader();
((Record)h).deserialize(archive, tag);
while (!h.getDone())
{
ZooDefs.OpCode opCode = EnumUtil <ZooDefs.OpCode> .DefinedCast(h.get_Type());
switch (opCode)
{
case ZooDefs.OpCode.create:
CreateRequest cr = new CreateRequest();
((Record)cr).deserialize(archive, tag);
add(Op.create(cr.getPath(), cr.getData(), cr.getAcl(), cr.getFlags()));
break;
case ZooDefs.OpCode.delete:
DeleteRequest dr = new DeleteRequest();
((Record)dr).deserialize(archive, tag);
add(Op.delete(dr.getPath(), dr.getVersion()));
break;
case ZooDefs.OpCode.setData:
SetDataRequest sdr = new SetDataRequest();
((Record)sdr).deserialize(archive, tag);
add(Op.setData(sdr.getPath(), sdr.getData(), sdr.getVersion()));
break;
case ZooDefs.OpCode.check:
CheckVersionRequest cvr = new CheckVersionRequest();
((Record)cvr).deserialize(archive, tag);
add(Op.check(cvr.getPath(), cvr.getVersion()));
break;
default:
throw new IOException("Invalid type of op");
}
((Record)h).deserialize(archive, tag);
}
archive.endRecord(tag);
}
public async Task <ActionResult <MaterialImage> > Create([FromQuery] CreateRequest request, [FromForm] IFormFile file)
{
if (!await _authManager.HasSitePermissionsAsync(request.SiteId,
Types.SitePermissions.MaterialImage))
{
return(Unauthorized());
}
if (file == null)
{
return(this.Error("请选择有效的文件上传"));
}
var fileName = Path.GetFileName(file.FileName);
var extName = PathUtils.GetExtension(fileName);
var site = await _siteRepository.GetAsync(request.SiteId);
if (!_pathManager.IsImageExtensionAllowed(site, extName))
{
return(this.Error("此图片格式已被禁止上传，请转换格式后上传!"));
}
var materialFileName = PathUtils.GetMaterialFileName(fileName);
var virtualDirectoryPath = PathUtils.GetMaterialVirtualDirectoryPath(UploadType.Image);
var directoryPath = PathUtils.Combine(_settingsManager.WebRootPath, virtualDirectoryPath);
var filePath = PathUtils.Combine(directoryPath, materialFileName);
await _pathManager.UploadAsync(file, filePath);
await _pathManager.AddWaterMarkAsync(site, filePath);
var image = new MaterialImage
{
GroupId = request.GroupId,
Title = fileName,
Url = PageUtils.Combine(virtualDirectoryPath, materialFileName)
};
await _materialImageRepository.InsertAsync(image);
return(image);
}
public override object InsertEvent(AuditEvent auditEvent)
{
var id = IdBuilder?.Invoke(auditEvent);
var createRequest = new CreateRequest <AuditEvent>(auditEvent, IndexBuilder?.Invoke(auditEvent), id);
var response = _client.Value.Create(createRequest);
if (response.IsValid && response.Result != Result.Error)
{
return(new ElasticsearchAuditEventId()
{
Id = response.Id, Index = response.Index
});
}
if (response.OriginalException != null)
{
throw response.OriginalException;
}
return("/");
}
public void Invoke(object Sender, object Element)
{
if (Element is CommandParameters)
{
CommandParameters cp = (CommandParameters)Element;
PrimaryKeyId parentKey = PrimaryKeyId.Parse(cp.CommandArguments["primaryKeyId"]);
PrimaryKeyId docId = PrimaryKeyId.Parse(((Control)Sender).Page.Request["ObjectId"]);
DocumentContentVersionEntity docVersion = (DocumentContentVersionEntity)BusinessManager.Load(DocumentContentVersionEntity.GetAssignedMetaClassName(), parentKey);
DocumentContentVersionEntity newVersion = (DocumentContentVersionEntity)BusinessManager.InitializeEntity(DocumentContentVersionEntity.GetAssignedMetaClassName());
newVersion.Name = docVersion.Name;
newVersion.OwnerDocumentId = docId;
CreateRequest request = new CreateRequest(newVersion);
request.Parameters.Add(DocumentContentVersionRequestParameters.Create_SourceVersionId, parentKey);
BusinessManager.Execute(request);
//CreateResponse response = (CreateResponse)BusinessManager.Execute(request);
//objectId = response.PrimaryKeyId;
CHelper.RequireBindGrid();
}
}
/// <summary>
/// This method first connects to the Organization service. Afterwards,
/// basic create, retrieve, update, and delete entity operations are performed.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
try
{
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri, serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// This statement is required to enable early-bound type support.
_serviceProxy.EnableProxyTypes();
CreateRequiredRecords();
//<snippetImportWebResources1>
//Read the descriptive data from the XML file
XDocument xmlDoc = XDocument.Load("../../ImportJob.xml");
//Create a collection of anonymous type references to each of the Web Resources
var webResources = from webResource in xmlDoc.Descendants("webResource")
select new
{
path = webResource.Element("path").Value,
displayName = webResource.Element("displayName").Value,
description = webResource.Element("description").Value,
name = webResource.Element("name").Value,
type = webResource.Element("type").Value
};
// Loop through the collection creating Web Resources
int counter = 0;
foreach (var webResource in webResources)
{
//<snippetImportWebResources2>
//Set the Web Resource properties
WebResource wr = new WebResource
{
Content = getEncodedFileContents(@"../../" + webResource.path),
DisplayName = webResource.displayName,
Description = webResource.description,
Name = _customizationPrefix + webResource.name,
LogicalName = WebResource.EntityLogicalName,
WebResourceType = new OptionSetValue(Int32.Parse(webResource.type))
};
// Using CreateRequest because we want to add an optional parameter
CreateRequest cr = new CreateRequest
{
Target = wr
};
//Set the SolutionUniqueName optional parameter so the Web Resources will be
// created in the context of a specific solution.
cr.Parameters.Add("SolutionUniqueName", _ImportWebResourcesSolutionUniqueName);
CreateResponse cresp = (CreateResponse)_serviceProxy.Execute(cr);
//</snippetImportWebResources2>
// Capture the id values for the Web Resources so the sample can delete them.
_webResourceIds[counter] = cresp.id;
counter++;
Console.WriteLine("Created Web Resource: {0}", webResource.displayName);
}
//</snippetImportWebResources1>
DeleteRequiredRecords(promptforDelete);
}
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>)
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
private CreateResponse ExecuteInternal(CreateRequest request)
{
var response = new CreateResponse();
response.Results["id"] = Create(request.Target);
return response;
}
private CreateRequest GetCreateWebResourceRequest(WebResource resource)
{
var createRequest = new CreateRequest
{
Target = resource
};
if (!string.IsNullOrWhiteSpace(DefaultConfiguration.SolutionUniqueName))
{
createRequest.Parameters.Add("SolutionUniqueName", DefaultConfiguration.SolutionUniqueName);
}
return createRequest;
}
private CreateRequest GetCreateWebResourceRequest(string entityLogicalName, AttributeTemplate attributeTemplate)
{
var contents =
CommonHelper.EncodeTo64(string.Format(DefaultConfiguration.WebResourceHtmlTemplate,
attributeTemplate.DisplayName));
var webResource = new WebResource
{
Content = contents,
DisplayName = attributeTemplate.DisplayNameShort,
Description = attributeTemplate.Description,
Name = entityLogicalName + "_" + attributeTemplate.LogicalName,
LogicalName = WebResource.EntityLogicalName,
WebResourceType = new OptionSetValue((int) Enums.WebResourceTypes.Html)
};
var createRequest = new CreateRequest
{
Target = webResource
};
if (!string.IsNullOrWhiteSpace(DefaultConfiguration.SolutionUniqueName))
{
createRequest.Parameters.Add("SolutionUniqueName", DefaultConfiguration.SolutionUniqueName);
}
return createRequest;
}
/// <summary>
/// This method first connects to the Organization service. Afterwards,
/// basic create, retrieve, update, and delete entity operations are performed.
/// </summary>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
try
{
//<snippetInvokeDuplicateDetectionForCreateAndUpdate1>
// Connect to the Organization service.
// The using statement assures that the service proxy will be properly disposed.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri,serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// This statement is required to enable early-bound type support.
_serviceProxy.EnableProxyTypes();
_service = (IOrganizationService)_serviceProxy;
CreateRequiredRecords();
// Create and account record with the named Proseware, Inc. and already existing Account Number.
Account account = new Account
{
Name = "Proseware, Inc.",
AccountNumber = "ACC005"
};
// Create operation by suppressing duplicate detection
CreateRequest reqCreate = new CreateRequest();
reqCreate.Target = account;
reqCreate.Parameters.Add("SuppressDuplicateDetection", true); // Change to false to activate the duplicate detection.
CreateResponse createResponse = (CreateResponse)_service.Execute(reqCreate);
_dupAccountId = createResponse.id;
Console.Write("Account: {0} {1} created with SuppressDuplicateDetection to true, ",
account.Name, account.AccountNumber);
// Retrieve the account containing with its few attributes.
ColumnSet cols = new ColumnSet(
new String[] { "name", "accountnumber"});
Account retrievedAccount = (Account)_service.Retrieve("account", _dupAccountId, cols);
Console.Write("retrieved, ");
// Update the existing account with new account number.
retrievedAccount.AccountNumber = "ACC006";
// Update operation – update record, if a duplicate is not found.
UpdateRequest reqUpdate = new UpdateRequest();
reqUpdate.Target = retrievedAccount;
reqUpdate["SuppressDuplicateDetection"] = false; // Duplicate detection is activated.
// Update the account record.
UpdateResponse updateResponse = (UpdateResponse)_service.Execute(reqUpdate);
Console.WriteLine("and updated.");
DeleteRequiredRecords(promptforDelete);
}
//</snippetInvokeDuplicateDetectionForCreateAndUpdate1>
}
// Catch any service fault exceptions that Microsoft Dynamics CRM throws.
catch (FaultException<Microsoft.Xrm.Sdk.OrganizationServiceFault>)
{
// You can handle an exception here or pass it back to the calling method.
throw;
}
}
public CreateResponse Create(CreateRequest request)
{
return _service.Create(request);
}
public void When_related_entities_and_relationship_are_used_child_entities_are_created()
{
var ctx = new XrmFakedContext();
var service = ctx.GetFakedOrganizationService();
ctx.AddRelationship("order_details",
new XrmFakedRelationship()
{
Entity1LogicalName = SalesOrder.EntityLogicalName, //Referenced
Entity1Attribute = "salesorderid", //Pk
Entity2LogicalName = SalesOrderDetail.EntityLogicalName,
Entity2Attribute = "salesorderid", //Lookup attribute
RelationshipType = XrmFakedRelationship.enmFakeRelationshipType.OneToMany
});
var order = new SalesOrder();
var orderItems = new EntityCollection(new List<Entity>()
{
new SalesOrderDetail(),
new SalesOrderDetail()
});
// Add related order items so it can be created in one request
order.RelatedEntities.Add(new Relationship
{
PrimaryEntityRole = EntityRole.Referenced,
SchemaName = "order_details"
}, orderItems);
var request = new CreateRequest
{
Target = order
};
var id = (service.Execute(request) as CreateResponse).id;
var createdOrderDetails = ctx.CreateQuery<SalesOrderDetail>().ToList();
Assert.Equal(createdOrderDetails.Count, 2);
Assert.Equal(createdOrderDetails[0].SalesOrderId.Id, id);
Assert.Equal(createdOrderDetails[1].SalesOrderId.Id, id);
}
/// <summary>
/// Begins the send.
/// </summary>
void IAlertMessage.BeginSend()
{
// Check File
//if (this.Files.Count > 0)
//{
// // Create Single EML
// this.MessageEntity.MessageContext = CreateMessageContent();
//}
// Create Message
CreateRequest request = new CreateRequest(this.MessageEntity);
request.Parameters.Add(OutgoingMessageQueuePlugin.AddToQueue, true);
request.Parameters.Add(OutgoingMessageQueuePlugin.SourceName, OutgoingEmailServiceType.AlertService.ToString());
BusinessManager.Execute(request);
}
public void Should_Be_Able_To_Insert_And_Retrieve_Inserted_Account_In_Single_Bulk_Request()
{
var connectionString = ConfigurationManager.ConnectionStrings["CrmOrganisation"];
using (var conn = new CrmDbConnection(connectionString.ConnectionString))
{
conn.Open();
var orgService = conn.OrganizationService;
// Create an ExecuteMultipleRequest object.
var multipleRequests = new ExecuteMultipleRequest()
{
// Assign settings that define execution behavior: continue on error, return responses.
Settings = new ExecuteMultipleSettings()
{
ContinueOnError = false,
ReturnResponses = true
},
// Create an empty organization request collection.
Requests = new OrganizationRequestCollection()
};
var entity = new Entity("account");
entity.Id = Guid.NewGuid();
entity["name"] = "experimental test";
CreateRequest createRequest = new CreateRequest
{
Target = entity
};
RetrieveRequest retrieveRequest = new RetrieveRequest
{
Target = new EntityReference(entity.LogicalName, entity.Id),
ColumnSet = new ColumnSet("createdon")
};
multipleRequests.Requests.Add(createRequest);
multipleRequests.Requests.Add(retrieveRequest);
// Execute all the requests in the request collection using a single web method call.
ExecuteMultipleResponse responseWithResults = (ExecuteMultipleResponse)orgService.Execute(multipleRequests);
var createResponseItem = responseWithResults.Responses[0];
CreateResponse createResponse = null;
if (createResponseItem.Response != null)
{
createResponse = (CreateResponse)createResponseItem.Response;
}
var retrieveResponseItem = responseWithResults.Responses[1];
RetrieveResponse retrieveResponse = null;
if (retrieveResponseItem.Response != null)
{
retrieveResponse = (RetrieveResponse)retrieveResponseItem.Response;
}
Console.Write(retrieveResponse.Entity["createdon"]);
}
}
public Guid Create(Entity entity)
{
var request = new CreateRequest
{
Target = entity
};
return ((CreateResponse) Execute(request)).id;
}
public UserQueryEntity FromQueryRequest(CreateRequest request)
{
var qr = request.queryRequest.ToQueryRequest();
var qd = DynamicQueryManager.Current.QueryDescription(qr.QueryName);
return qr.ToUserQuery(qd, QueryLogic.GetQueryEntity(qd.QueryName), request.defaultPagination.ToPagination(), withoutFilters: false);
}
public JsonResult Create(CreateRequest createRequest)
{
var target = _urlsRespository.Add(createRequest.LongUrl);
return Json(target);
}
/// <summary>
/// Begins the send.
/// </summary>
void IAlertMessage.BeginSend()
{
this.MessageEntity.FromId = ConvertOriginalIdToPrincipalId(this.MessageEntity.FromId);
this.MessageEntity.ToId = ConvertOriginalIdToPrincipalId(this.MessageEntity.ToId);
CreateRequest request = new CreateRequest(this.MessageEntity);
request.Parameters.Add(OutgoingMessageQueuePlugin.AddToQueue, true);
request.Parameters.Add(OutgoingMessageQueuePlugin.SourceName, OutgoingEmailServiceType.AlertService.ToString());
BusinessManager.Execute(request);
}
private void Button_Click_4(object sender, RoutedEventArgs e)
{
if (ctrl.CrmConnectionMgr != null && ctrl.CrmConnectionMgr.CrmSvc != null && ctrl.CrmConnectionMgr.CrmSvc.IsReady)
{
CrmServiceClient svcClient = ctrl.CrmConnectionMgr.CrmSvc;
if (svcClient.IsReady)
{
OpenFileDialog fileDialog = new OpenFileDialog();
fileDialog.DefaultExt = ".xlsx";
if (fileDialog.ShowDialog().Value)
{
string FileName = fileDialog.FileName;
Workbook workbook = new Workbook(FileName);
Worksheet MyWorksheet = workbook.Worksheets["Aspose Export"];
DataTable dt = MyWorksheet.Cells.ExportDataTable(0, 0, MyWorksheet.Cells.Rows.Count, MyWorksheet.Cells.Columns.Count, true);
foreach (DataRow dr in dt.Rows)
{
Entity CrmRecord = new Entity(SelectedEntity);
foreach (DataColumn th in dt.Columns)
{
CrmRecord.Attributes.Add(th.ColumnName, dr[th.ColumnName].ToString());
}
CreateRequest req = new CreateRequest();
req.Target = CrmRecord;
CreateResponse res = (CreateResponse)svcClient.OrganizationServiceProxy.Execute(req);
}
}
}
}
}
/// <summary>
/// This sample demonstrates how to execute a collection of message requests using a single web service
/// call and optionally return the results.
/// </summary>
/// <seealso cref="http://msdn.microsoft.com/en-us/library/gg328075.aspx"/>
/// <param name="serverConfig">Contains server connection information.</param>
/// <param name="promptforDelete">When True, the user will be prompted to delete all
/// created entities.</param>
public void Run(ServerConnection.Configuration serverConfig, bool promptforDelete)
{
try
{
//<snippetExecuteMultiple1>
// Get a reference to the organization service.
using (_serviceProxy = new OrganizationServiceProxy(serverConfig.OrganizationUri, serverConfig.HomeRealmUri,serverConfig.Credentials, serverConfig.DeviceCredentials))
{
// Enable early-bound type support to add/update entity records required for this sample.
_serviceProxy.EnableProxyTypes();
#region Execute Multiple with Results
// Create an ExecuteMultipleRequest object.
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 input = GetCollectionOfEntitiesToCreate();
// Add a CreateRequest for each entity to the request collection.
foreach (var entity in input.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)_serviceProxy.Execute(requestWithResults);
// Display the results returned in the responses.
foreach (var responseItem in responseWithResults.Responses)
{
// A valid response.
if (responseItem.Response != null)
DisplayResponse(requestWithResults.Requests[responseItem.RequestIndex], responseItem.Response);
// An error has occurred.
else if (responseItem.Fault != null)
DisplayFault(requestWithResults.Requests[responseItem.RequestIndex],
responseItem.RequestIndex, responseItem.Fault);
}
//</snippetExecuteMultiple1>
#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 = GetCollectionOfEntitiesToUpdate();
foreach (var entity in update.Entities)
{
UpdateRequest updateRequest = new UpdateRequest { Target = entity };
requestWithNoResults.Requests.Add(updateRequest);
}
ExecuteMultipleResponse responseWithNoResults =
(ExecuteMultipleResponse)_serviceProxy.Execute(requestWithNoResults);
// There should be no responses unless there was an error. Only the first error
// should be returned. That is the behavior defined in the settings.
if (responseWithNoResults.Responses.Count > 0)
{
foreach (var responseItem in responseWithNoResults.Responses)
{
if (responseItem.Fault != null)
DisplayFault(requestWithNoResults.Requests[responseItem.RequestIndex],
responseItem.RequestIndex, responseItem.Fault);
}
}
else
{
Console.WriteLine("All account records have been updated successfully.");
}
#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 = GetCollectionOfEntitiesToUpdateWithErrors();
foreach (var entity in updateWithErrors.Entities)
{
UpdateRequest updateRequest = new UpdateRequest { Target = entity };
requestWithContinueOnError.Requests.Add(updateRequest);
}
ExecuteMultipleResponse responseWithContinueOnError =
(ExecuteMultipleResponse)_serviceProxy.Execute(requestWithContinueOnError);
// There should be no responses except for those that contain an error.
if (responseWithContinueOnError.Responses.Count > 0)
{
if (responseWithContinueOnError.Responses.Count < requestWithContinueOnError.Requests.Count)
{
Console.WriteLine("Response collection contain a mix of successful response objects and errors.");
}
foreach (var responseItem in responseWithContinueOnError.Responses)
{
if (responseItem.Fault != null)
DisplayFault(requestWithContinueOnError.Requests[responseItem.RequestIndex],
responseItem.RequestIndex, responseItem.Fault);
}
}
else
{
// No errors means all transactions are successful.
Console.WriteLine("All account records have been updated successfully.");
}
#endregion Execute Multiple with Continue On Error
DeleteRequiredRecords(promptforDelete);
}
}
// <snippetExecuteMultiple2>
catch (FaultException<OrganizationServiceFault> fault)
{
// Check if the maximum batch size has been exceeded. The maximum batch size is only included in the fault if it
// the input request collection count exceeds the maximum batch size.
if (fault.Detail.ErrorDetails.Contains("MaxBatchSize"))
{
int maxBatchSize = Convert.ToInt32(fault.Detail.ErrorDetails["MaxBatchSize"]);
if (maxBatchSize < requestWithResults.Requests.Count)
{
// Here you could reduce the size of your request collection and re-submit the ExecuteMultiple request.
// For this sample, that only issues a few requests per batch, we will just print out some info. However,
// this code will never be executed because the default max batch size is 1000.
Console.WriteLine("The input request collection contains %0 requests, which exceeds the maximum allowed (%1)",
requestWithResults.Requests.Count, maxBatchSize);
}
}
// Re-throw so Main() can process the fault.
throw;
}
// </snippetExecuteMultiple2>
}
/// <summary>
/// Issues a <c>CreateRequest</c> to the target <c>CrmService</c>.
/// </summary>
/// <param name="entity">The <c>Entity</c> to be created.</param>
protected void CreateNewEntity(Entity entity)
{
if (entity == null)
{
throw new AdapterException(string.Format(CultureInfo.CurrentCulture, Resources.ArgumentNullExceptionMessage), new ArgumentNullException("entity")) { ExceptionId = AdapterException.SystemExceptionGuid };
}
entity.Attributes.Remove(CRM2011AdapterUtilities.IsNew);
OptionSetValue state = null;
OptionSetValue status = null;
state = RemoveStateCode(entity);
if (state != null)
{
status = RemoveStatusCode(entity);
}
CreateRequest request = new CreateRequest() { Target = entity };
if (this.DoesDetectDuplicates == true)
{
request["SuppressDuplicateDetection"] = false;
}
try
{
PrepEntityForCreate(entity);
this.CallCrmExecuteWebMethod(request);
this.ApplyStateAndStatus(entity, state, status);
}
catch (AdapterException ex)
{
if (ex.ExceptionId == ErrorCodes.DuplicateDetected)
{
entity = this.DetectDuplicates(request);
}
else
{
throw;
}
}
}
public void When_related_entities_are_used_without_relationship_info_exception_is_raised()
{
var ctx = new XrmFakedContext();
var service = ctx.GetFakedOrganizationService();
var order = new SalesOrder();
var orderItems = new EntityCollection(new List<Entity>()
{
new SalesOrderDetail(),
new SalesOrderDetail()
});
// Add related order items so it can be created in one request
order.RelatedEntities.Add(new Relationship
{
PrimaryEntityRole = EntityRole.Referenced,
SchemaName = "order_details"
}, orderItems);
var request = new CreateRequest
{
Target = order
};
var exception = Assert.Throws<Exception>(() => service.Execute(request));
Assert.Equal(exception.Message, "Relationship order_details does not exist in the metadata cache");
}
/// <summary>
/// Issues a <c>CompundCreateRequest</c> to the target <c>CrmService</c>.
/// </summary>
/// <param name="entity">The <c>Entity</c> to be created.</param>
/// <param name="children">The <c>Array</c> of <c>Entity</c> objects that contains the children.</param>
protected void CreateNewCompoundEntity(Entity entity, Entity[] children)
{
if (entity == null)
{
throw new AdapterException(string.Format(CultureInfo.CurrentCulture, Resources.ArgumentNullExceptionMessage), new ArgumentNullException("entity")) { ExceptionId = AdapterException.SystemExceptionGuid };
}
entity.Attributes.Remove(CRM2011AdapterUtilities.IsNew);
OptionSetValue state = null;
OptionSetValue status = null;
state = RemoveStateCode(entity);
if (state != null)
{
status = RemoveStatusCode(entity);
}
entity.RelatedEntities.Add(new Relationship((entity.LogicalName == "salesorder" ? "order" : entity.LogicalName) + "_details"), new EntityCollection(children.ToList()));
CreateRequest request = new CreateRequest() { Target = entity };
if (this.DoesDetectDuplicates == true)
{
request["SuppressDuplicateDetection"] = false;
}
PrepEntityForCreate(entity);
this.CallCrmExecuteWebMethod(request);
this.ApplyStateAndStatus(entity, state, status);
}
/// <summary>
/// Ensure that a publisher is created so that we can prefix fields with govd
/// </summary>
/// <returns></returns>
public void EnsureGovdeliveryPublisher()
{
Entity publisher = new Entity("publisher");
publisher["customizationprefix"] = "govd";
publisher["uniquename"] = "GovDelivery";
publisher["friendlyname"] = "govdelivery";
publisher["description"] = "GovDelivery publisher";
QueryExpression query = new QueryExpression()
{
EntityName = "publisher",
ColumnSet = new ColumnSet("customizationprefix"),
Criteria = new FilterExpression()
{
FilterOperator = LogicalOperator.And,
Conditions =
{
new ConditionExpression()
{
AttributeName = "customizationprefix",
Operator = ConditionOperator.Equal,
Values = { "govd" }
}
}
},
};
EntityCollection entities = this.getService().RetrieveMultiple(query);
if (entities.Entities.Count == 0)
{
CreateRequest publisherRequest = new CreateRequest
{
Target = publisher
};
this.getService().Execute(publisherRequest);
}
}
/// <summary>
/// https://developers.podio.com/doc/embeds/add-an-embed-726483
/// </summary>
public Embed AddAnEmbed(string url)
{
var requestData = new CreateRequest()
{
Url = url
};
return PodioRestHelper.JSONRequest<Embed>(Constants.PODIOAPI_BASEURL + "/embed/", _client.AuthInfo.AccessToken, requestData, PodioRestHelper.RequestMethod.POST).Data;
}
/// <summary>
/// Create a user without or without a password and return a ClaimsIdentity representing the user created.
/// </summary>
/// <param name="request">Instance of CreateRequest</param>
/// <returns>Instance of CreateResponse</returns>
public async Task<CreateResponse> CreateAsync(CreateRequest request)
{
CreateResponse response = new CreateResponse();
try
{
AspNetUser newUser = new AspNetUser()
{
Id = Guid.NewGuid().ToString(),
FirstName = request.FirstName,
LastName = request.LastName,
UserName = request.UserName,
Discriminator = "ApplicationUser" //Change as per your requirements
};
IdentityResult result;
if (!string.IsNullOrWhiteSpace(request.Password))
result = await this.UserManager.CreateAsync(newUser, request.Password);
else
result = await this.UserManager.CreateAsync(newUser);
if (result.Succeeded)
{
string authType = EnumStringValue.GetStringValue(request.AuthenticationType);
ClaimsIdentity identity = await this.UserManager.CreateIdentityAsync(newUser, authType);
response.UserId = new Guid(newUser.Id);
response.ClaimIdentity = identity.ConvertToClaimIdentityView();
response.Success = true;
}
else
{
response.AddErrors(response.Errors);
response.Success = false;
}
}
catch (Exception e)
{
response.Success = false;
response.Errors.Add(e.Message);
}
return response;
}
public CreateRequestHandler(IContainerManager containerManager, Request request)
: base(containerManager, request)
{
this.request = (CreateRequest)request;
}
