public LogViewModel(List <LogEntry> log, Process process, ContentItem item)
{
Log = log;
Process = process;
Item = item;
Part = item?.As <TransformalizeTaskPart>();
}
protected override void OnCreatingPost(ContentItem contentItem)
{
// give edit permission to current user in case current user has no permission
var contentPermissionPart = contentItem.As <ContentItemPermissionPart>();
if (contentPermissionPart != null)
{
int userId = this.services.WorkContext.CurrentUser.Id;
var userPrermissions = this.contentOwnershipHelper.GetUserPermissionRecordsForItem(contentItem, userId);
if (userPrermissions == null || userPrermissions.Count() == 0)
{
byte accessType = ContentItemPermissionAccessTypes.SharedForEdit;
this.contentOwnershipHelper.Create(
new ContentItemPermissionDetailRecord
{
AccessType = accessType,
User = new Users.Models.UserPartRecord {
Id = userId
}
},
contentItem
, false);
}
}
}
protected override void OnDisplay(ContentItem contentItem, dynamic model)
{
TicketPart ticketPart = contentItem.As <TicketPart>();
if (ticketPart.Record.RelatedContentItem != null)
{
var relatedContentItem = this.contentManager.Get(ticketPart.Record.RelatedContentItem.Id, VersionOptions.AllVersions);
TitlePart titlePart = relatedContentItem.As <TitlePart>();
CommonPart commonPart = relatedContentItem.As <CommonPart>();
if (titlePart != null && commonPart != null)
{
model.RelatedContentItem = new
{
Owner = commonPart.Owner,
Title = titlePart.Title,
Id = relatedContentItem.Id,
ContentType = relatedContentItem.ContentType
};
}
}
model.IsCurrentUserCustomer = this.crmContentOwnershipService.IsCurrentUserCustomer();
model.CurrentUserCanEditContent = this.crmContentOwnershipService.CurrentUserCanEditContent(contentItem);
model.CurrentUserCanChangePermission = this.crmContentOwnershipService.CurrentUserCanChangePermission(contentItem, new ModelStateDictionary());
}
public async Task <IActionResult> TableAsync([FromBody] DataTablePart part)
{
ContentItem contentItem = await _contentManager.NewAsync("DatatableWidget");
// EXPLICIT syntax
DataTablePart testPart = contentItem.As <DataTablePart>();
testPart.JsonData = part.JsonData;
contentItem.Apply(testPart);
try
{
await _contentManager.CreateAsync(contentItem);
//do create here
//send contentitemid
ContentResult result = new ContentResult
{
ContentType = "application/json"
};
//result.Content = System.Text.Json.JsonSerializer.Serialize(new { result = contentItem.ContentItemId });
//result.StatusCode = 200;
//return result;
return(Ok(contentItem.ContentItemId));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.GetBaseException().Message));
}
}
//private void CreateContactForMail(PartialRecord partialRecord, string mail) {
// var ci = CreateContact(partialRecord);
// CommunicationEmailRecord cer = new CommunicationEmailRecord();
// cer.Email = mail;
// cer.DataInserimento = DateTime.Now;
// cer.DataModifica = DateTime.Now;
// cer.Produzione = true;
// cer.Validated = true;
// cer.EmailContactPartRecord_Id = ci.Id;
// _repositoryCommunicationEmailRecord.Create(cer);
//}
//private void CreateContactForSms(PartialRecord partialRecord, string prefix, string sms) {
// var ci = CreateContact(partialRecord);
// CommunicationSmsRecord csr = new CommunicationSmsRecord();
// csr.Prefix = prefix;
// csr.Sms = sms;
// csr.DataInserimento = DateTime.Now;
// csr.DataModifica = DateTime.Now;
// csr.Produzione = true;
// csr.Validated = true;
// csr.SmsContactPartRecord_Id = ci.Id;
// _repositoryCommunicationSmsRecord.Create(csr);
//}
private ContentItem CreateContact(PartialRecord partialRecord)
{
ContentItem ci = _contentManager.Create("CommunicationContact");
ci.As <TitlePart>().Title = partialRecord.Name;
return(ci);
}
protected DriverResult DetailDisplay(MilestonePart part, dynamic shapeHelper)
{
List <DriverResult> shapes = new List <DriverResult>();
EditMilestoneViewModel model = this.Convert(part);
shapes.Add(ContentShape("Parts_Milestone_Data", () => shapeHelper.Parts_Milestone_Data(Model: model)));
var memberShapes = this.GetMilestoneMembers(part.Id, "Pinboard", false).ToList();
memberShapes.ForEach(c =>
{
ContentItem contentItem = c.ContentItem;
TicketPart ticket = contentItem.As <TicketPart>();
c.StatusId = ticket.Record.StatusRecord != null ? (int?)ticket.Record.StatusRecord.Id : null;
});
dynamic ticketsModel = new ExpandoObject();
ticketsModel.Part = part;
ticketsModel.Items = memberShapes;
// we want to represent the tickets in a table where there is a column for each status.
var statusRecords = this.basicDataService.GetStatusRecords().ToList();
ticketsModel.StatusRecords = statusRecords;
shapes.Add(ContentShape("Parts_Milestone_Tickets", () => shapeHelper.Parts_Milestone_Tickets(Model: JsonConvert.SerializeObject(ticketsModel))));
return(this.Combined(shapes.ToArray()));
}
public void StoreLikeDynamic(ContentItem item, string[] listProperty, object value)
{
var part = item.As <UserPolicyPart>();
if (part != null)
{
if (listProperty.Length == 2)
{
if (listProperty[0] == "UserPolicyPart")
{
if (listProperty[1] == "UserPolicyAnswers")
{
var newValues = new List <PolicyForUserViewModel>();
var arr = value as IEnumerable;
foreach (dynamic answer in arr)
{
newValues.Add(new PolicyForUserViewModel {
PolicyTextId = Convert.ToInt32(answer.Id),
Accepted = answer.Accepted
});
}
_policyServices.PolicyForItemMassiveUpdate(newValues, item);
}
}
}
}
}
public void UpdateCalendarForSchedulerEventViewModel(ContentItem item, SchedulerEventViewModel model)
{
//var categories = _eventCategoryService.GetEventCategoriesByIdList(model.EventCategoryIds).ToList();
var eventPart = item.As <EventPart>();
if (model.EventCategoryIds != null && model.EventCategoryIds.Any())
{
_categoryService.UpdateCategoriesForEvent(item, model.EventCategoryIds);
}
eventPart.As <TitlePart>().Title = model.Title.Replace(@"\,", ",");
eventPart.RecurrenceId = model.RecurrenceId;
eventPart.RecurrenceRule = model.RecurrenceRule;
eventPart.RecurrenceException = model.RecurrenceException;
eventPart.TimeZone = model.Timezone;
eventPart.Description = model.Description.Replace(@"\,", ",");
eventPart.AddressLocation = model.Location.Replace(@"\,", ",");
eventPart.Url = model.Url;
eventPart.ImportedFromGoogleCalendar = model.ImportFromGoogleCalendar;
eventPart.ImportUid = model.ImportUid;
eventPart.AllDayEvent = model.IsAllDay;
if (model.IsAllDay && model.ImportFromGoogleCalendar)
{
model.End = model.End.AddDays(-1); // catch for import
}
eventPart.StartDate = model.Start;
eventPart.EndDate = model.End;
}
public void Discover(ShapeTableBuilder builder)
{
builder.Describe("Widget")
.Configure(descriptor => {
// todo: have "alternates" for chrome
descriptor.Wrappers.Add("Widget_Wrapper");
descriptor.Wrappers.Add("Widget_ControlWrapper");
})
.OnCreated(created => {
var widget = created.Shape;
widget.Child.Add(created.New.PlaceChildContent(Source: widget));
})
.OnDisplaying(displaying => {
var widget = displaying.Shape;
widget.Classes.Add("widget");
ContentItem contentItem = displaying.Shape.ContentItem;
if (contentItem != null)
{
widget.Classes.Add("widget-" + contentItem.ContentType.HtmlClassify());
var zoneName = contentItem.As <WidgetPart>().Zone;
// Widget__[ZoneName] e.g. Widget-SideBar
displaying.ShapeMetadata.Alternates.Add("Widget__" + zoneName);
// Widget__[ContentType] e.g. Widget-BlogArchive
displaying.ShapeMetadata.Alternates.Add("Widget__" + contentItem.ContentType);
}
});
}
public static string GetDescription(this ContentItem contentItem, BodyAspect bodyAspect)
{
var rssFeedItemPart = contentItem.Get <ContentPart>(Constants.RssFeedItem.ContentPart);
if (rssFeedItemPart != null && !string.IsNullOrWhiteSpace(rssFeedItemPart.Get <TextField>(Constants.RssFeedItem.DescriptionFieldName).Text))
{
return(rssFeedItemPart.Get <TextField>(Constants.RssFeedItem.DescriptionFieldName).Text);
}
if (contentItem.Has <MetaTagsPart>() && !string.IsNullOrWhiteSpace(contentItem.As <MetaTagsPart>()?.Description))
{
return(contentItem.As <MetaTagsPart>()?.Description);
}
return(bodyAspect.Body != null ? $"<![CDATA[{bodyAspect.Body?.ToString()}]]>" : string.Empty);
}
public override void EditPost(XRpcStruct rpcStruct, ContentItem contentItem)
{
if (contentItem.As <TitlePart>() != null)
{
contentItem.Alter <TitlePart>(x => x.Title = rpcStruct.Optional <string>("title"));
}
}
public static string GetTitle(this ContentItem contentItem)
{
var rssFeedItemPart = contentItem.Get <ContentPart>(Constants.RssFeedItem.ContentPart);
if (rssFeedItemPart != null && !string.IsNullOrWhiteSpace(rssFeedItemPart.Get <TextField>(Constants.RssFeedItem.TitleFieldName).Text))
{
return(rssFeedItemPart.Get <TextField>(Constants.RssFeedItem.TitleFieldName).Text);
}
if (contentItem.Has <MetaTagsPart>() && !string.IsNullOrWhiteSpace(contentItem.As <MetaTagsPart>()?.Title))
{
return(contentItem.As <MetaTagsPart>()?.Title);
}
return(contentItem.DisplayText);
}
public void Discover(ShapeTableBuilder builder)
{
builder.Describe("Content")
.OnDisplaying(displaying =>
{
if (AdminFilter.IsApplied(new RequestContext(_workContext.GetContext().HttpContext, new RouteData())))
{
return;
}
if (displaying.ShapeMetadata.DisplayType != "Detail")
{
return;
}
ContentItem contentItem = displaying.Shape.ContentItem;
if (contentItem != null)
{
var wavePart = contentItem.As <WavePart>();
if (wavePart == null)
{
return;
}
displaying.ShapeMetadata.Wrappers.Add("Wave_Wrapper");
}
});
}
public dynamic TakeSnapshot(ContentItem contentItem)
{
// var part = contentItem.As<TicketPart>();
//var part = contentItem.As<WorkBookPart>();
if (contentItem == null)
{
return(null);
}
ContentItem oldData = new ContentItem();
oldData.ContentType = contentItem.ContentType;
oldData.Author = contentItem.Author;
var testPart = contentItem.As <ContentPart>();
oldData.Apply(testPart);
// TicketPartRecord oldData = new TicketPartRecord();
// oldData.StatusRecord = part.Record.StatusRecord;
// oldData.TicketType = part.Record.TicketType;
// oldData.Title = part.Record.Title;
// oldData.Description = part.Record.Description;
// oldData.DueDate = part.Record.DueDate;
// oldData.PriorityRecord = part.Record.PriorityRecord;
// oldData.Service = part.Record.Service;
// WorkBookPart oldData = new WorkBookPart();
// oldData.prop = part.prop;
return(oldData);
}
private void CopyPolicyAnswers(ContentItem src, ContentItem dest)
{
var srcPolicy = src.As <UserPolicyPart>();
var destPolicy = dest.As <UserPolicyPart>();
if (srcPolicy != null && destPolicy != null)
{
IPolicyServices policyServices = null;
_orchardServices.WorkContext.TryResolve <IPolicyServices>(out policyServices);
if (policyServices != null)
{
var policyList = new List <PolicyForUserViewModel>();
var srcAnswers = policyServices.GetPolicyAnswersForContent(srcPolicy.Id);
foreach (var policy in srcAnswers)
{
policyList.Add(new PolicyForUserViewModel {
PolicyTextId = policy.PolicyTextInfoPartRecord.Id,
Accepted = policy.Accepted,
AnswerDate = policy.AnswerDate,
UserId = (policy.UserPartRecord == null) ? null : (int?)policy.UserPartRecord.Id
});
}
policyServices.PolicyForItemMassiveUpdate(policyList, dest);
}
}
}
public async Task <ContentItem> AssignGroupAsync(ContentItem profile, string groupContentItemId)
{
if (profile == null)
{
return(null);
}
using (var scope = await _shellHost.GetScopeAsync(_shellSettings))
{
var contentManager = scope.ServiceProvider.GetRequiredService <IContentManager>();
profile.Alter <ProfileGroupedPart>(x => x.GroupContentItemId = groupContentItemId);
profile.Apply(nameof(ProfileGroupedPart), profile.As <ProfileGroupedPart>());
ContentExtensions.Apply(profile, profile);
await contentManager.UpdateAsync(profile);
await contentManager.PublishAsync(profile);
await _session.CommitAsync();
return(profile);
}
}
public override async Task <IDisplayResult> EditAsync(ContentItem model, BuildEditorContext context)
{
var layerMetadata = model.As <LayerMetadata>();
if (layerMetadata == null)
{
layerMetadata = new LayerMetadata();
// Are we loading an editor that requires layer metadata?
if (await context.Updater.TryUpdateModelAsync(layerMetadata, Prefix, m => m.Zone, m => m.Position) &&
!String.IsNullOrEmpty(layerMetadata.Zone))
{
model.Weld(layerMetadata);
}
else
{
return(null);
}
}
return(Initialize <LayerMetadataEditViewModel>("LayerMetadata_Edit", async shape =>
{
shape.LayerMetadata = layerMetadata;
shape.Layers = (await _layerService.GetLayersAsync()).Layers;
})
.Location("Content:before"));
}
public dynamic TakeSnapshot(ContentItem contentItem)
{
var part = contentItem.As <AttachToFolderPart>();
if (part == null)
{
return(null);
}
dynamic oldData = new ExpandoObject();
var oldDataDictionary = oldData as IDictionary <string, object>;
if (part.Record.Folder != null)
{
var folder = this.folderService.GetFolder(part.Record.Folder.Id);
oldData.Folder = new FolderPartRecord
{
Id = folder.Record.Id,
Title = folder.Record.Title,
ContentItemRecord = new ContentItemRecord {
Id = folder.Record.ContentItemRecord.Id
}
};
}
else
{
oldData.Folder = null;
}
oldData.VersionId = contentItem.VersionRecord.Id;
oldData.ContentItemId = part.ContentItem.Id;
return(oldData);
}
public void RemoveTagsForContentItem(ContentItem contentItem)
{
if (contentItem.Id == 0)
{
throw new OrchardException(T("Error removing tag to content item: the content item has not been created yet."));
}
_contentTagRepository.Flush();
var tagsPart = contentItem.As <TagsPart>();
// delete orphan tags (for each tag, if there is no other contentItem than the one being deleted, it's an orphan)
foreach (var tag in tagsPart.CurrentTags)
{
if (_contentTagRepository.Count(x => x.TagsPartRecord.Id != contentItem.Id) == 0)
{
_tagRepository.Delete(tag);
}
}
// delete tag links with this contentItem (ContentTagRecords)
foreach (var record in _contentTagRepository.Fetch(x => x.TagsPartRecord.Id == contentItem.Id))
{
_contentTagRepository.Delete(record);
}
}
public override Task <IDisplayResult> DisplayAsync(ContentItem contentItem, BuildDisplayContext context)
{
var part = contentItem.As <TermPart>();
if (part == null)
{
return(Task.FromResult <IDisplayResult>(null));
}
return(Task.FromResult <IDisplayResult>(
Initialize <TermPartViewModel>("TermPart", async model =>
{
var settings = await _siteService.GetSiteSettingsAsync();
var pager = new PagerParameters()
{
Page = 1, PageSize = settings.PageSize
};
await context.Updater.TryUpdateModelAsync <PagerParameters>(pager);
var count = (Math.Max(0, pager.Page.Value - 1)) * pager.PageSize.Value;
var query = _session.Query <ContentItem>()
.With <TaxonomyIndex>(x => x.TermContentItemId == part.ContentItem.ContentItemId &&
x.ContentType == "BlogPost")
.With <ContentItemIndex>(x => x.Published)
.OrderByDescending(x => x.CreatedUtc);
var totalCount = await query.CountAsync();
var items = await query.Skip(Math.Max(0, count)).Take(pager.PageSize.Value).ListAsync();
model.TaxonomyContentItemId = part.TaxonomyContentItemId;
model.ContentItem = part.ContentItem;
model.ContentItems = await _contentManager.LoadAsync(items);
model.Pager = (await context.New.Pager(pager)).TotalItemCount(totalCount);
}).Location("Detail", "Content:5")
));
}
public void UpdateTerms(ContentItem contentItem, IEnumerable <TermPart> terms, string field)
{
var termsPart = contentItem.As <TermsPart>();
// removing current terms for specific field
var fieldIndexes = termsPart.Terms
.Where(t => t.Field == field)
.Select((t, i) => i)
.OrderByDescending(i => i)
.ToList();
foreach (var x in fieldIndexes)
{
termsPart.Terms.RemoveAt(x);
}
// adding new terms list
foreach (var term in terms)
{
termsPart.Terms.Add(
new TermContentItem {
TermsPartRecord = termsPart.Record,
TermRecord = term.Record, Field = field
});
}
}
protected virtual void OnCreatingPost(ContentItem contentItem)
{
// give edit/owner permission to current customer/operator in case they have no permission
var contentPermissionPart = contentItem.As <ContentItemPermissionPart>();
if (contentPermissionPart != null)
{
int userId = this.services.WorkContext.CurrentUser.Id;
var userPrermissions = this.contentOwnershipHelper.GetUserPermissionRecordsForItem(contentItem, userId);
if (userPrermissions == null || userPrermissions.Count() == 0)
{
bool isCustomer = this.crmContentOwnershipService.IsCurrentUserCustomer();
byte accessType = isCustomer ? ContentItemPermissionAccessTypes.SharedForEdit : ContentItemPermissionAccessTypes.Assignee;
this.contentOwnershipHelper.Create(
new ContentItemPermissionDetailRecord
{
AccessType = accessType,
User = new Users.Models.UserPartRecord {
Id = userId
},
ContentItemPermissionPartRecord = contentPermissionPart.Record
},
contentItem
, false);
}
}
}
public void UpdateForContentItem(ContentItem item, string[] links)
{
var record = item.As <TPrimaryPart>().Record;
var oldLinks = _contentLinkRepository.Fetch(
r => r.PrimaryPartRecord == record);
var lookupNew = links != null
? links.ToDictionary(r => r, r => false)
: new Dictionary <string, bool>();
// Delete the rewards that are no longer there and mark the ones that should stay
foreach (var contentRewardProgramsRecord in oldLinks)
{
var newReward = lookupNew.FirstOrDefault(x => x.Key == contentRewardProgramsRecord.RelatedPartRecord.Id.ToString());
if (newReward.Key != null)
{
lookupNew[newReward.Key] = true;
}
else
{
_contentLinkRepository.Delete(contentRewardProgramsRecord);
}
}
// Add the new rewards
foreach (var reward in lookupNew.Where(kvp => !kvp.Value).Select(kvp => kvp.Key))
{
_contentLinkRepository.Create(new TContentLinkRecord {
PrimaryPartRecord = record,
RelatedPartRecord = _contentManager.Get(int.Parse(reward)).As <TRelatedPart>().Record
});
}
}
public bool ProcessIsAllowed(ContentItem contentItem)
{
// protect admin users
var user = contentItem.As <UserPart>();
if (user == null)
{
// no way to make any judgement, so assume that whoever started the process
// knwos what they are doing
return(true);
}
if (!string.IsNullOrEmpty(_workContextAccessor.GetContext().CurrentSite.SuperUser) &&
string.Equals(user.UserName, _workContextAccessor.GetContext().CurrentSite.SuperUser, StringComparison.Ordinal))
{
// protect super user
return(false);
}
if (_authorizationService.TryCheckAccess(StandardPermissions.SiteOwner, user, null))
{
// Prevent processing if the contact is for an admin
return(false);
}
// by default we return true, to avoid blocking when we are not sure we should
return(true);
}
public override IDisplayResult Display(ContentItem contentItem, IUpdateModel updater)
{
var testContentPart = contentItem.As <TestContentPartA>();
if (testContentPart == null)
{
return(null);
}
return(Combine(
// A new shape is created and the properties of the object are bound to it when rendered
Shape("TestContentPartA", testContentPart).Location("Detail", "Content"),
// New shape, no initialization, custom location
Shape("LowerDoll").Location("Detail", "Footer"),
// New shape
Shape("TestContentPartA",
ctx => ctx.New.TestContentPartA().Creating(_creating++),
shape =>
{
shape.Processing = _processing++;
return Task.CompletedTask;
})
.Location("Detail", "Content")
.Cache("lowerdoll2", cache => cache.During(TimeSpan.FromSeconds(5))),
// A strongly typed shape model is used and initialized when rendered
Shape <TestContentPartAShape>(shape => { shape.Line = "Strongly typed shape"; return Task.CompletedTask; })
.Location("Detail", "Content:2"),
// Cached shape
Shape("LowerDoll")
.Location("Detail", "/Footer")
.Cache("lowerdoll", cache => cache.During(TimeSpan.FromSeconds(5)))
));
}
public void UpdateTaskForContentItem(ContentItem contentItem, EditTaskViewModel viewModel)
{
var taskPart = contentItem.As <TaskPart>();
taskPart.Deadline = viewModel.Deadline;
taskPart.ElapsedTime = viewModel.ElapsedTime;
taskPart.EstimatedTime = viewModel.EstimatedTime;
taskPart.IsSubtask = viewModel.IsSubtask;
if (viewModel.ProjectId != "" && !viewModel.IsSubtask)
{
taskPart.ProjectRecord = _contentManager.Query(ContentTypes.Project)
.List <ProjectPart>()
.FirstOrDefault(project => project.Id.ToString().Equals(viewModel.ProjectId))
.Record;
}
if (viewModel.ParentId != "" && viewModel.IsSubtask)
{
taskPart.ParentRecord = _contentManager.Query(ContentTypes.Task)
.List <TaskPart>()
.FirstOrDefault(task => task.Id.ToString().Equals(viewModel.ParentId))
.Record;
}
}
protected override void OnCreatePost(ContentItem contentItem)
{
bool isCustomer = this.crmContentOwnershipService.IsCurrentUserCustomer();
if (isCustomer)
{
var ticketSettings = this.services.WorkContext.CurrentSite.As <TicketSettingPart>();
var ticket = contentItem.As <TicketPart>();
int statusId = ticketSettings.CreatedCustomerTicketState;
if (statusId == default(int))
{
var statusRecords = this.basicDataService.GetStatusRecords().ToList();
var newStatus = statusRecords.FirstOrDefault(c => c.StatusTypeId == StatusRecord.NewStatus);
statusId = newStatus.Id;
}
ticket.Record.StatusRecord = new StatusRecord {
Id = statusId
};
ticket.Record.DueDate = DateTime.UtcNow.AddDays(ticketSettings.CustomerTicketDueDateDays);
}
base.OnCreatePost(contentItem);
}
public ContentItem CheckDataRestricitons(ContentItem contentItem, Permission permission)
{
if (_isSuperUser || (_isBackEnd == false && _applyToFrontEnd == false))
{
return(contentItem);
}
List <List <string> > userRestrictionsToTest = null;
if (permission == Permissions.ViewContent || permission == Permissions.PreviewContent)
{
userRestrictionsToTest = _userRestrictionsForView;
}
else
{
userRestrictionsToTest = _userRestrictionsForEdit;
}
var dataProtectionContextPart = contentItem.As <DataProtectionContextPart>();
if (dataProtectionContextPart != null)
{
var dataProtectionContext = new List <string>();
if (string.IsNullOrWhiteSpace(dataProtectionContextPart.Context) == false)
{
foreach (var row in dataProtectionContextPart.Context.Trim().Split(','))
{
dataProtectionContext.Add(row);
}
}
// se l'item non ha nessun data context è visibile a tutti
if (dataProtectionContext.Count == 0)
{
return(contentItem);
}
// almeno un set di restrictions dell'utente deve essere presente nell'item
var granted = false;
foreach (var set in userRestrictionsToTest)
{
// check sul singolo set di restrictions
var setGranted = true;
foreach (var row in set)
{
if (dataProtectionContext.Contains(row) == false)
{
setGranted = false;
break;
}
}
if (setGranted)
{
granted = true;
break;
}
}
if (granted == false)
{
return(null);
}
}
return(contentItem);
}
public override void EditPost(XRpcStruct rpcStruct, ContentItem contentItem)
{
if (contentItem.As <HtmlBodyPart>() != null)
{
contentItem.Alter <HtmlBodyPart>(x => x.Html = rpcStruct.Optional <string>("description"));
}
}
private void StoreAddress(AddressRecord addressToStore, ContentItem contact)
{
addressToStore.NwazetContactPartRecord_Id = contact.Id;
bool AddNewAddress = true;
foreach (var existingAddressRecord in contact.As <NwazetContactPart>().NwazetAddressRecord)
{
if (addressToStore.Id == existingAddressRecord.Id ||
addressToStore.Equals(existingAddressRecord))
{
AddNewAddress = false;
existingAddressRecord.TimeStampUTC = DateTime.UtcNow;
// little trick to cause nHibernate to "replace" the old address
// with the updated one:
addressToStore.Id = existingAddressRecord.Id;
_addressRecord.Update(addressToStore);
_addressRecord.Flush();
}
}
if (AddNewAddress)
{
_addressRecord.Create(addressToStore);
_addressRecord.Flush();
}
}
