public AnnouncementAssignedAttribute RemoveAttachment(int announcementAssignedAttributeId)
{
Trace.Assert(Context.PersonId.HasValue);
Trace.Assert(Context.SchoolLocalId.HasValue);
using (var uow = Update())
{
var da = new AnnouncementAssignedAttributeDataAccess(uow);
var attribute = da.GetById(announcementAssignedAttributeId);
if (!attribute.AttachmentRef.HasValue)
{
throw new ChalkableException("Attribute has no attachments for remove.");
}
if (attribute.IsStiAttribute)
{
var activityAssignedAttribute = ConnectorLocator.ActivityAssignedAttributeConnector.GetAttribute(attribute.SisActivityId.Value, attribute.SisActivityAssignedAttributeId.Value);
activityAssignedAttribute.Attachment = null;
ConnectorLocator.ActivityAssignedAttributeConnector.Update(attribute.SisActivityId.Value, attribute.SisActivityAssignedAttributeId.Value, activityAssignedAttribute);
}
attribute.AttachmentRef = null;
da.Update(attribute);
uow.Commit();
return(attribute);
}
}
public override void Submit(int announcementId)
{
Trace.Assert(Context.SchoolLocalId.HasValue);
var res = GetAnnouncementDetails(announcementId);
if (res.ClassAnnouncementData.Title == null || Exists(res.ClassAnnouncementData.Title, res.ClassAnnouncementData.ClassRef, res.ClassAnnouncementData.Expires, res.ClassAnnouncementData.Id))
{
throw new ChalkableException("Invalid Class Announcement Title");
}
using (var uow = Update())
{
var da = CreateClassAnnouncementDataAccess(uow);
AnnouncementSecurity.EnsureInModifyAccess(res, Context);
if (res.ClassAnnouncementData.IsDraft)
{
ServiceLocator.AnnouncementAssignedAttributeService.ValidateAttributes(res.AnnouncementAttributes);
res.ClassAnnouncementData.State = AnnouncementState.Created;
res.ClassAnnouncementData.Created = Context.NowSchoolTime.Date;
var activity = new Activity();
MapperFactory.GetMapper <Activity, AnnouncementDetails>().Map(activity, res);
activity = ConnectorLocator.ActivityConnector.CreateActivity(res.ClassAnnouncementData.ClassRef, activity);
if (da.Exists(activity.Id))
{
throw new ChalkableException("Announcement with such activityId already exists");
}
var annAttDa = new AnnouncementAssignedAttributeDataAccess(uow);
annAttDa.Delete(res.AnnouncementAttributes);
MapperFactory.GetMapper <AnnouncementDetails, Activity>().Map(res, activity);
var attributes = res.AnnouncementAttributes.Where(x => x.Attachment != null).ToList();
if (attributes.Count > 0)
{
var atts = new AttachmentDataAccess(uow).GetBySisAttachmentIds(attributes.Select(a => a.Attachment.SisAttachmentId.Value).ToList());
foreach (var attribute in res.AnnouncementAttributes)
{
if (attribute.Attachment == null)
{
continue;
}
var att = atts.FirstOrDefault(x => x.SisAttachmentId == attribute.Attachment.SisAttachmentId);
if (att == null)
{
continue;
}
attribute.AttachmentRef = att.Id;
}
}
annAttDa.Insert(res.AnnouncementAttributes);
}
da.Update(res.ClassAnnouncementData);
uow.Commit();
}
}
public AnnouncementAssignedAttribute AddAttachment(AnnouncementTypeEnum announcementType, int announcementId, int assignedAttributeId, int attachmentId)
{
Trace.Assert(Context.PersonId.HasValue);
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(announcementId);
if (!CanAttach(ann))
{
throw new ChalkableSecurityException();
}
using (var uow = Update())
{
var da = new AnnouncementAssignedAttributeDataAccess(uow);
var attribute = da.GetById(assignedAttributeId);
if (attribute.AttachmentRef > 0)
{
throw new ChalkableSisException("You can't attach more than one file to an attribute");
}
var attDa = new AttachmentDataAccess(uow);
var attachment = attDa.GetById(attachmentId);
if (attachment.PersonRef != Context.PersonId)
{
throw new ChalkableSecurityException();
}
attribute.AttachmentRef = attachment.Id;
attribute.Attachment = attachment;
da.Update(attribute);
if (announcementType == AnnouncementTypeEnum.Class)
{
if (!attachment.SisAttachmentId.HasValue)
{
var attContent = ServiceLocator.AttachementService.GetAttachmentContent(attachment);
var stiAtt = ConnectorLocator.AttachmentConnector.UploadAttachment(attachment.Name, attContent.Content).Last();
MapperFactory.GetMapper <Attachment, StiAttachment>().Map(attachment, stiAtt);
attDa.Update(attachment);
}
if (attribute.SisActivityAssignedAttributeId.HasValue)
{
var stiAttribute = ConnectorLocator.ActivityAssignedAttributeConnector.GetAttribute(attribute.SisActivityId.Value, attribute.SisActivityAssignedAttributeId.Value);
MapperFactory.GetMapper <ActivityAssignedAttribute, AnnouncementAssignedAttribute>().Map(stiAttribute, attribute);
ConnectorLocator.ActivityAssignedAttributeConnector.Update(stiAttribute.ActivityId, stiAttribute.Id, stiAttribute);
}
}
uow.Commit();
return(attribute);
}
}
public static IList <Pair <AnnouncementAssignedAttribute, AnnouncementAssignedAttribute> > CopyNonStiAttributes(IDictionary <int, int> fromToAnnouncementIds,
UnitOfWork unitOfWork, IServiceLocatorSchool serviceLocator, ConnectorLocator connectorLocator)
{
//var attachmentDA = new AttachmentDataAccess(unitOfWork);
var annAssignedAttributeDA = new AnnouncementAssignedAttributeDataAccess(unitOfWork);
var attributesForCopying = annAssignedAttributeDA.GetLastListByAnnIds(fromToAnnouncementIds.Select(x => x.Key).ToList(), int.MaxValue)
.Where(x => !x.SisActivityAssignedAttributeId.HasValue).ToList();
var fromToAttributes = new List <Pair <AnnouncementAssignedAttribute, AnnouncementAssignedAttribute> >();
foreach (var announcementPair in fromToAnnouncementIds)
{
var assignedAttToCopy = attributesForCopying.Where(x => x.AnnouncementRef == announcementPair.Key).ToList();
foreach (var attributeToCopy in assignedAttToCopy)
{
var newAttribute = new AnnouncementAssignedAttribute
{
AnnouncementRef = announcementPair.Value,
AttributeTypeId = attributeToCopy.AttributeTypeId,
Name = attributeToCopy.Name,
Text = attributeToCopy.Text,
VisibleForStudents = attributeToCopy.VisibleForStudents,
AttachmentRef = attributeToCopy.AttachmentRef,
Attachment = attributeToCopy.Attachment
};
//if (attributeToCopy.Attachment != null)
//{
// var attachment = new Attachment
// {
// Name = attributeToCopy.Attachment.Name,
// PersonRef = serviceLocator.Context.PersonId.Value,
// Uuid = null,
// UploadedDate = serviceLocator.Context.NowSchoolTime,
// LastAttachedDate = serviceLocator.Context.NowSchoolTime,
// };
// attachment.Id = attachmentDA.InsertWithEntityId(attachment);
// newAttribute.AttachmentRef = attachment.Id;
// newAttribute.Attachment = attachment;
//}
fromToAttributes.Add(new Pair <AnnouncementAssignedAttribute, AnnouncementAssignedAttribute>(attributeToCopy, newAttribute));
}
}
annAssignedAttributeDA.Insert(fromToAttributes.Select(x => x.Second).ToList());
return(fromToAttributes);
}
protected virtual IList <AnnouncementDetails> BuildGetDetailsesResult(SqlDataReader reader)
{
IList <AnnouncementDetails> res = new List <AnnouncementDetails>();
while (reader.Read())
{
var ann = reader.Read <AnnouncementDetails>();
ann.AnnouncementData = ReadAnnouncementData(ann, reader);
ann.StudentAnnouncements = new List <StudentAnnouncementDetails>();
res.Add(ann);
}
reader.NextResult();
var annAtts = reader.ReadList <AnnouncementAttachment>(true);
foreach (var ann in res)
{
ann.AttachmentNames = annAtts.Where(x => x.AnnouncementRef == ann.Id).Select(x => x.Attachment.Name).ToList();
}
reader.NextResult();
var owners = reader.ReadList <Person>();
reader.NextResult();
var announcementQnAs = AnnouncementQnADataAccess.ReadAnnouncementQnAComplexes(reader);
reader.NextResult();
var announcementAttributes = AnnouncementAssignedAttributeDataAccess.ReadAttributes(reader);
reader.NextResult();
var announcementApplications = reader.ReadList <AnnouncementApplication>();
reader.NextResult();
var announcementStandards = reader.ReadList <AnnouncementStandardDetails>();
reader.NextResult();
var announcementAttachments = reader.ReadList <AnnouncementAttachment>(true);
foreach (var ann in res)
{
ann.Owner = owners.FirstOrDefault(x => ann.OwnereId == x.Id);
ann.AnnouncementQnAs = announcementQnAs.Where(x => x.AnnouncementRef == ann.Id).ToList();
ann.AnnouncementAttributes = announcementAttributes.Where(x => x.AnnouncementRef == ann.Id).ToList();
ann.AnnouncementApplications = announcementApplications.Where(x => x.AnnouncementRef == ann.Id).ToList();
ann.AnnouncementStandards = announcementStandards.Where(x => x.AnnouncementRef == ann.Id).ToList();
ann.AnnouncementAttachments = announcementAttachments.Where(x => x.AnnouncementRef == ann.Id).ToList();
}
return(res);
}
public void Delete(int assignedAttributeId)
{
BaseSecurity.EnsureAdminOrTeacher(Context);
Trace.Assert(Context.PersonId.HasValue);
Trace.Assert(Context.SchoolLocalId.HasValue);
DoUpdate(u =>
{
var da = new AnnouncementAssignedAttributeDataAccess(u);
var attribute = da.GetById(assignedAttributeId);
if (attribute.SisActivityId.HasValue && attribute.SisActivityAssignedAttributeId.HasValue)
{
ConnectorLocator.ActivityAssignedAttributeConnector.Delete(attribute.SisActivityId.Value, attribute.SisActivityAssignedAttributeId.Value);
}
da.Delete(assignedAttributeId);
});
}
public AnnouncementAssignedAttribute Add(AnnouncementTypeEnum announcementType, int announcementId, int attributeTypeId)
{
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(announcementId);
Trace.Assert(Context.PersonId.HasValue);
Trace.Assert(Context.SchoolLocalId.HasValue);
var attributeType = ServiceLocator.AnnouncementAttributeService.GetAttributeById(attributeTypeId, true);
using (var uow = Update())
{
if (!CanAttach(ann))
{
throw new ChalkableSecurityException();
}
var annAttribute = new AnnouncementAssignedAttribute
{
AnnouncementRef = ann.Id,
AttributeTypeId = attributeType.Id,
Text = "",
VisibleForStudents = false,
Name = attributeType.Name
};
if (announcementType == AnnouncementTypeEnum.Class)
{
var announcement = ServiceLocator.ClassAnnouncementService.GetClassAnnouncemenById(announcementId);
if (announcement.SisActivityId.HasValue)
{
var activityAssignedAttr = new ActivityAssignedAttribute();
MapperFactory.GetMapper <ActivityAssignedAttribute, AnnouncementAssignedAttribute>().Map(activityAssignedAttr, annAttribute);
activityAssignedAttr.Text = " ";
activityAssignedAttr = ConnectorLocator.ActivityAssignedAttributeConnector.CreateActivityAttribute(announcement.SisActivityId.Value, activityAssignedAttr);
MapperFactory.GetMapper <AnnouncementAssignedAttribute, ActivityAssignedAttribute>().Map(annAttribute, activityAssignedAttr);
annAttribute.Name = attributeType.Name;//activity attr returns null name
}
}
var da = new AnnouncementAssignedAttributeDataAccess(uow);
var id = da.InsertWithEntityId(annAttribute);
uow.Commit();
return(da.GetById(id));
}
}
public static IList <AnnouncementAssignedAttribute> CopyNonStiAttributes(int fromAnnouncementId, IList <int> toAnnouncementIds,
UnitOfWork unitOfWork, IServiceLocatorSchool serviceLocator, ConnectorLocator connectorLocator)
{
var da = new AnnouncementAssignedAttributeDataAccess(unitOfWork);
var attributesForCopying = da.GetListByAnntId(fromAnnouncementId);
attributesForCopying = attributesForCopying.Where(x => !x.SisActivityAssignedAttributeId.HasValue).ToList();
var attributes = new List <AnnouncementAssignedAttribute>();
foreach (var attributeForCopying in attributesForCopying)
{
foreach (var toAnnouncementId in toAnnouncementIds)
{
var attribute = new AnnouncementAssignedAttribute
{
AnnouncementRef = toAnnouncementId,
AttributeTypeId = attributeForCopying.AttributeTypeId,
Name = attributeForCopying.Name,
Text = attributeForCopying.Text,
VisibleForStudents = attributeForCopying.VisibleForStudents,
AttachmentRef = attributeForCopying.AttachmentRef,
Attachment = attributeForCopying.Attachment
};
//if (attributeForCopying.Attachment != null)
//{
// var attContent = serviceLocator.AttachementService.GetAttachmentContent(attributeForCopying.Attachment);
// if (attContent.Content != null)
// {
// var att = AttachmentService.Upload(attContent.Attachment.Name, attContent.Content, attContent.Attachment.IsStiAttachment, unitOfWork, serviceLocator, connectorLocator);
// attribute.AttachmentRef = att.Id;
// attribute.Attachment = att;
// }
//}
attributes.Add(attribute);
}
}
da.Insert(attributes);
return(da.GetLastListByAnnIds(toAnnouncementIds, attributes.Count));
}
public AnnouncementAssignedAttribute UploadAttachment(AnnouncementTypeEnum announcementType, int announcementId, int assignedAttributeId, byte[] bin, string name)
{
Trace.Assert(Context.PersonId.HasValue && Context.SchoolLocalId.HasValue);
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(announcementId);
using (var uow = Update())
{
var da = new AnnouncementAssignedAttributeDataAccess(uow);
var assignedAttribute = da.GetById(assignedAttributeId);
if (!CanAttach(ann))
{
throw new ChalkableSecurityException();
}
if (assignedAttribute.AttachmentRef > 0)
{
throw new ChalkableSisException("You can't attach more than one file to an attribute");
}
var isStiAttribute = assignedAttribute.IsStiAttribute || announcementType == AnnouncementTypeEnum.Class;
var attachment = AttachmentService.Upload(name, bin, isStiAttribute, uow, ServiceLocator, ConnectorLocator);
assignedAttribute.AttachmentRef = attachment.Id;
assignedAttribute.Attachment = attachment;
da.Update(assignedAttribute);
if (assignedAttribute.IsStiAttribute)
{
var stiAttribute = ConnectorLocator.ActivityAssignedAttributeConnector.GetAttribute(
assignedAttribute.SisActivityId.Value,
assignedAttribute.SisActivityAssignedAttributeId.Value);
MapperFactory.GetMapper <ActivityAssignedAttribute, AnnouncementAssignedAttribute>().Map(stiAttribute, assignedAttribute);
ConnectorLocator.ActivityAssignedAttributeConnector.Update(stiAttribute.ActivityId, stiAttribute.Id, stiAttribute);
}
uow.Commit();
return(assignedAttribute);
}
}
public void Edit(AnnouncementTypeEnum announcementType, int announcementId, IList <AssignedAttributeInputModel> inputAttributes)
{
BaseSecurity.EnsureAdminOrTeacher(Context);
Trace.Assert(Context.PersonId.HasValue);
Trace.Assert(Context.SchoolLocalId.HasValue);
var annoncement = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(announcementId); // security check
if (inputAttributes != null)
{
DoUpdate(u =>
{
var da = new AnnouncementAssignedAttributeDataAccess(u);
var attributesForUpdate = da.GetAttributesByIds(inputAttributes.Select(x => x.Id).ToList());
foreach (var attribute in attributesForUpdate)
{
var inputAttr = inputAttributes.FirstOrDefault(x => x.Id == attribute.Id);
if (inputAttr == null)
{
continue;
}
attribute.AnnouncementRef = inputAttr.AnnouncementId;
attribute.Name = inputAttr.Name;
attribute.Text = inputAttr.Text;
attribute.VisibleForStudents = inputAttr.VisibleForStudents;
attribute.AttributeTypeId = inputAttr.AttributeTypeId;
attribute.AttachmentRef = inputAttr.AttachmentId;
}
if (!annoncement.IsDraft)
{
ValidateAttributes(attributesForUpdate);
}
da.Update(attributesForUpdate);
});
}
}
