public AnnouncementApplication AddToAnnouncement(int announcementId, AnnouncementTypeEnum type, Guid applicationId)
{
var app = ServiceLocator.ServiceLocatorMaster.ApplicationService.GetApplicationById(applicationId);
EnsureApplicationPermission(app.Id);
using (var uow = Update())
{
var ann = ServiceLocator.GetAnnouncementService(type).GetAnnouncementDetails(announcementId);
if (!ApplicationSecurity.CanAddToAnnouncement(app, ann, Context))
{
throw new ChalkableSecurityException();
}
var aa = new AnnouncementApplication
{
AnnouncementRef = announcementId,
ApplicationRef = applicationId,
Active = false,
Order = ServiceLocator.GetAnnouncementService(type).GetNewAnnouncementItemOrder(ann)
};
var da = new AnnouncementApplicationDataAccess(uow);
da.Insert(aa);
uow.Commit();
aa = da.GetAll(new AndQueryCondition
{
{ nameof(AnnouncementApplication.AnnouncementRef), announcementId },
{ nameof(AnnouncementApplication.ApplicationRef), applicationId },
{ nameof(AnnouncementApplication.Active), false }
}).OrderByDescending(x => x.Id).First();
return(aa);
}
}
public Announcement Add(int announcementId, AnnouncementTypeEnum type, int attachmentId)
{
var annDetails = ServiceLocator.GetAnnouncementService(type).GetAnnouncementDetails(announcementId);
Trace.Assert(Context.PersonId.HasValue);
Trace.Assert(Context.SchoolLocalId.HasValue);
if (!CanAttach(annDetails))
{
throw new ChalkableSecurityException();
}
using (var u = Update())
{
var attDa = new AttachmentDataAccess(u);
var att = attDa.GetById(attachmentId);
if (att.PersonRef != Context.PersonId)
{
throw new ChalkableSecurityException();
}
var annAtt = new AnnouncementAttachment
{
AnnouncementRef = annDetails.Id,
AttachedDate = Context.NowSchoolTime,
Order = ServiceLocator.GetAnnouncementService(type).GetNewAnnouncementItemOrder(annDetails),
AttachmentRef = attachmentId
};
new AnnouncementAttachmentDataAccess(u).Insert(annAtt);
att.LastAttachedDate = annAtt.AttachedDate;
attDa.Update(att);
u.Commit();
NotifyUsers(annDetails, type);
}
return(annDetails);
}
//TODO : notification sending
public AnnouncementQnA AskQuestion(int announcementId, AnnouncementTypeEnum announcementType, string question)
{
Trace.Assert(Context.PersonId.HasValue && Context.SchoolLocalId.HasValue);
using (var uow = Update())
{
var da = new AnnouncementQnADataAccess(uow);
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(announcementId);
var annQnA = new AnnouncementQnAComplex
{
AnnouncementRef = announcementId,
AskerRef = Context.PersonId.Value,
Question = question,
QuestionTime = Context.NowSchoolTime,
State = AnnouncementQnAState.Asked
};
da.Insert(annQnA);
uow.Commit();
annQnA = da.GetAnnouncementQnA(new AnnouncementQnAQuery
{
AnnouncementId = announcementId,
CallerId = annQnA.AskerRef,
SchoolId = Context.SchoolLocalId.Value
}).AnnouncementQnAs.OrderByDescending(x => x.Id).First();
ServiceLocator.NotificationService.AddAnnouncementNotificationQnToAuthor(annQnA.Id, ann.Id, announcementType);
return(annQnA);
}
}
public AnnouncementQnA Answer(int announcementQnAId, AnnouncementTypeEnum announcementType, string question, string answer)
{
if (!Context.PersonId.HasValue)
{
throw new UnassignedUserException();
}
var annQnA = GetAnnouncementQnA(announcementQnAId);
if (!CanEditQuestion(annQnA))
{
throw new ChalkableSecurityException();
}
annQnA.State = AnnouncementQnAState.Answered;
annQnA.Question = question;
if (Context.Role == CoreRoles.TEACHER_ROLE && (!annQnA.AnswererRef.HasValue || annQnA.AnswererRef == Context.PersonId))
{
var answerer = ServiceLocator.PersonService.GetPersonDetails(Context.PersonId.Value);
annQnA.Answerer = answerer;
annQnA.AnswererRef = answerer.Id;
annQnA.AnsweredTime = Context.NowSchoolTime;
annQnA.Answer = answer;
}
AnnouncementQnAStorage.Update(annQnA);
ServiceLocator.NotificationService.AddAnnouncementNotificationAnswerToStudent(annQnA.Id, annQnA.AnnouncementRef, announcementType);
return(annQnA);
}
public void UpdateAnnouncementApplicationMeta(int announcementApplicationId, AnnouncementTypeEnum announcementType, string text, string imageUrl, string description)
{
Trace.Assert(Context.SchoolLocalId.HasValue);
Trace.Assert(Context.PersonId.HasValue);
using (var uow = Update())
{
var da = new AnnouncementApplicationDataAccess(uow);
var aa = da.GetById(announcementApplicationId);
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(aa.AnnouncementRef);
if (!ann.IsOwner && Context.Role != CoreRoles.DISTRICT_ADMIN_ROLE)
{
throw new ChalkableSecurityException(ChlkResources.ERR_SECURITY_EXCEPTION);
}
aa.Text = text;
if (string.IsNullOrWhiteSpace(imageUrl) || !Uri.IsWellFormedUriString(imageUrl, UriKind.Absolute))
{
imageUrl = null;
}
aa.ImageUrl = imageUrl;
aa.Description = description;
da.Update(aa);
uow.Commit();
}
}
protected ActionResult EditTitle(int announcementId, AnnouncementTypeEnum announcementType, string title, Func <string, bool> existsAction)
{
if (!existsAction(title))
{
SchoolLocator.GetAnnouncementService(announcementType).EditTitle(announcementId, title);
return(Json(true));
}
return(Json(false));
}
public void AttachAppToAnnouncement(int announcementAppId, AnnouncementTypeEnum announcementType)
{
var aa = GetAnnouncementApplication(announcementAppId);
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(aa.AnnouncementRef);
if (ann.IsOwner)
{
throw new ChalkableSecurityException(ChlkResources.ERR_SECURITY_EXCEPTION);
}
aa.Active = true;
AnnouncementApplicationStorage.Update(aa);
}
public void AddAnnouncementNewAttachmentNotification(int announcementId, AnnouncementTypeEnum announcementType)
{
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementDetails(announcementId);
var persons = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementRecipientPersons(announcementId, StudentFilterEnum.All);
var notifications = new List <Notification>();
foreach (var person in persons)
{
notifications.Add(builder.BuildAnnouncementNewAttachmentNotification(Context.NowSchoolTime, ann, person));
}
AddNotifications(notifications);
}
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);
}
}
private void NotifyUsers(Announcement announcement, AnnouncementTypeEnum type)
{
if (!announcement.IsDraft)
{
if (announcement.IsOwner)
{
ServiceLocator.NotificationService.AddAnnouncementNewAttachmentNotification(announcement.Id, type);
}
else
{
ServiceLocator.NotificationService.AddAnnouncementNewAttachmentNotificationToOwner(announcement.Id, type, Context.PersonId.Value);
}
}
}
public void UpdateAnnouncementApplicationMeta(int announcementApplicationId, AnnouncementTypeEnum announcementType, string text,
string imageUrl, string description)
{
var aa = GetAnnouncementApplication(announcementApplicationId);
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(aa.AnnouncementRef);
if (ann.IsOwner)
{
throw new ChalkableSecurityException(ChlkResources.ERR_SECURITY_EXCEPTION);
}
aa.Text = text;
aa.ImageUrl = imageUrl;
aa.Description = description;
AnnouncementApplicationStorage.Update(aa);
}
private string GetAnnouncementType(AnnouncementTypeEnum at)
{
switch (at)
{
case AnnouncementTypeEnum.LessonPlan:
return("lesson plan");
case AnnouncementTypeEnum.Class:
return("activity");
case AnnouncementTypeEnum.Admin:
return("admin announcement");
default:
return("announcement");
}
}
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 Announcement RemoveFromAnnouncement(int announcementAppId, AnnouncementTypeEnum announcementType)
{
try
{
var aa = AnnouncementApplicationStorage.GetById(announcementAppId);
AnnouncementApplicationStorage.Delete(announcementAppId);
var res = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(aa.AnnouncementRef);
if (res.IsOwner)
{
throw new ChalkableSecurityException(ChlkResources.ERR_SECURITY_EXCEPTION);
}
return(res);
}
catch (Exception)
{
throw new ChalkableException(String.Format(ChlkResources.ERR_CANT_DELETE_ANNOUNCEMENT_APPLICATION, announcementAppId));
}
}
public void UpdateAnnouncementRecipientData(int?announcementId, AnnouncementTypeEnum announcementType, int?schoolYearId, int?personId, int?roleId,
bool complete, int?classId, DateTime?fromDate, DateTime?toDate, bool filterByExpiryDate)
{
var param = new Dictionary <string, object>
{
[nameof(announcementId)] = announcementId,
[nameof(complete)] = complete,
[nameof(personId)] = personId,
[nameof(roleId)] = roleId,
[nameof(schoolYearId)] = schoolYearId,
[nameof(classId)] = classId,
[nameof(announcementType)] = (int)announcementType,
[nameof(fromDate)] = fromDate,
[nameof(toDate)] = toDate,
[nameof(filterByExpiryDate)] = filterByExpiryDate
};
ExecuteStoredProcedure("spUpdateAnnouncementRecipientData", param);
}
public void AttachAppToAnnouncement(int announcementAppId, AnnouncementTypeEnum announcementType)
{
Trace.Assert(Context.SchoolLocalId.HasValue);
Trace.Assert(Context.PersonId.HasValue);
using (var uow = Update())
{
var da = new AnnouncementApplicationDataAccess(uow);
var aa = da.GetById(announcementAppId);
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(aa.AnnouncementRef);
if (!ann.IsOwner && Context.Role != CoreRoles.DISTRICT_ADMIN_ROLE)
{
throw new ChalkableSecurityException(ChlkResources.ERR_SECURITY_EXCEPTION);
}
aa.Active = true;
da.Update(aa);
uow.Commit();
}
}
public AnnouncementQnA AskQuestion(int announcementId, AnnouncementTypeEnum announcementType, string question)
{
Trace.Assert(Context.PersonId.HasValue);
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementDetails(announcementId);
//if(!ann.PrimaryTeacherRef.HasValue)
// throw new ChalkableException("There is no teachers for that item");
var annQnA = new AnnouncementQnAComplex
{
AnnouncementRef = announcementId,
AskerRef = Context.PersonId.Value,
Question = question,
QuestionTime = Context.NowSchoolTime,
State = AnnouncementQnAState.Asked,
Asker = ServiceLocator.PersonService.GetPersonDetails(Context.PersonId.Value),
Answerer = ServiceLocator.PersonService.GetPersonDetails(ann.Owner.Id)
};
if (ann.ClassAnnouncementData != null)
{
annQnA.ClassRef = ann.ClassAnnouncementData.ClassRef;
}
if (ann.LessonPlanData != null)
{
annQnA.ClassRef = ann.LessonPlanData.ClassRef;
}
if (ann.AdminAnnouncementData != null)
{
annQnA.AdminRef = ann.AdminAnnouncementData.AdminRef;
}
AnnouncementQnAStorage.Add(annQnA);
annQnA = GetAnnouncementQnA(new AnnouncementQnAQuery
{
AnnouncementId = announcementId,
CallerId = annQnA.AskerRef
}).AnnouncementQnAs.OrderByDescending(x => x.Id).First();
ServiceLocator.NotificationService.AddAnnouncementNotificationQnToAuthor(annQnA.Id, ann.Id, announcementType);
return(annQnA);
}
public AnnouncementViewModel(Announcement announcement)
{
Title = announcement.Title;
Body = announcement.Body;
if (announcement.Level.FirstOrDefault() is MultipleChoiceOption announcementLevel)
{
Level = announcementLevel.ToEnum <AnnouncementLevelEnum>();
}
if (announcement.Location.FirstOrDefault() is MultipleChoiceOption announcementLocation)
{
Location = announcementLocation.ToEnum <AnnouncementLocationEnum>();
}
if (announcement.Type.FirstOrDefault() is MultipleChoiceOption announcementType)
{
Type = announcementType.ToEnum <AnnouncementTypeEnum>();
}
}
public AnnouncementApplication AddToAnnouncement(int announcementId, AnnouncementTypeEnum announcementType, Guid applicationId)
{
var app = ServiceLocator.ServiceLocatorMaster.ApplicationService.GetApplicationById(applicationId);
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementDetails(announcementId);
if (!ApplicationSecurity.CanAddToAnnouncement(app, ann, Context))
{
throw new ChalkableSecurityException();
}
var aa = new AnnouncementApplication
{
AnnouncementRef = announcementId,
ApplicationRef = applicationId,
Active = false,
Order = ServiceLocator.GetAnnouncementService(announcementType).GetNewAnnouncementItemOrder(ann)
};
AnnouncementApplicationStorage.Add(aa);
aa = AnnouncementApplicationStorage.GetAll(announcementId, applicationId, false).OrderByDescending(x => x.Id).First();
return(aa);
}
/// <summary>
/// Evaluates points for a card in a game
/// </summary>
/// <param name="gameType">curent game</param>
/// <param name="card">card to be evaluated</param>
/// <returns></returns>
public static int EvaluateCard( AnnouncementTypeEnum gameType, Card card )
{
int val = 0;
switch( gameType )
{
case AnnouncementTypeEnum.AllTrumps :
val = EvaluateTrumps( card );
break;
case AnnouncementTypeEnum.NoTrumps :
val = EvaluateNoTrumps( card );
break;
case AnnouncementTypeEnum.Spades :
if( card.CardColor == CardColor.Spades )
val = EvaluateTrumps( card );
else
val = EvaluateNoTrumps( card );
break;
case AnnouncementTypeEnum.Hearts :
if( card.CardColor == CardColor.Hearts )
val = EvaluateTrumps( card );
else
val = EvaluateNoTrumps( card );
break;
case AnnouncementTypeEnum.Diamonds :
if( card.CardColor == CardColor.Diamonds )
val = EvaluateTrumps( card );
else
val = EvaluateNoTrumps( card );
break;
case AnnouncementTypeEnum.Clubs :
if( card.CardColor == CardColor.Clubs )
val = EvaluateTrumps( card );
else
val = EvaluateNoTrumps( card );
break;
case AnnouncementTypeEnum.Pass :
break;
}
return val;
}
/// <summary>
/// If announcement made by this player is valid according to game rules
/// </summary>
public bool IsValid(Player player, AnnouncementTypeEnum type, bool isDoubled, bool isRedoubled)
{
//no player
if (player == null)
{
throw new ArgumentNullException("Player", "Bidding player cannot be null");
}
//legal pass
if (type == AnnouncementTypeEnum.Pass)
{
if (!isDoubled && !isRedoubled)
{
return(true);
}
else
{
return(false);
}
}
if (_lastValidAnnouncement.CompareTo(type) < 0 && !isDoubled && !isRedoubled)
{
return(true);
}
if (_lastValidAnnouncement.CompareTo(type) == 0 && !IsLastValidBidByTeam(player) && !_lastValidAnnouncement.IsReDoubled)
{
if (!_lastValidAnnouncement.IsDoubled && isDoubled && !isRedoubled)
{
return(true);
}
if (_lastValidAnnouncement.IsDoubled && !isDoubled && isRedoubled)
{
return(true);
}
}
return(false);
}
public Announcement AddAttachment(int announcementId, AnnouncementTypeEnum annType, byte[] content, string name)
{
var ann = ServiceLocator.GetAnnouncementService(annType).GetAnnouncementDetails(announcementId);
if (!Context.PersonId.HasValue)
{
throw new UnassignedUserException();
}
if (!CanAttach(ann))
{
throw new ChalkableSecurityException();
}
var uuid = UploadToCrocodoc(name, content);
var annAtt = new AnnouncementAttachment
{
AnnouncementRef = ann.Id,
AttachedDate = Context.NowSchoolTime,
Order = ServiceLocator.GetAnnouncementService(annType).GetNewAnnouncementItemOrder(ann)
};
var attachment = AnnouncementAttachmentStorage.Add(annAtt);
ServiceLocator.StorageBlobService.AddBlob(ATTACHMENT_CONTAINER_ADDRESS, attachment.Id.ToString(CultureInfo.InvariantCulture), content);
if (ann.State != AnnouncementState.Draft)
{
if (ann.IsOwner)
{
ServiceLocator.NotificationService.AddAnnouncementNewAttachmentNotification(announcementId, annType);
}
else
{
ServiceLocator.NotificationService.AddAnnouncementNewAttachmentNotificationToOwner(announcementId, annType, Context.PersonId.Value);
}
}
return(ann);
}
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 AnnouncementQnA Answer(int announcementQnAId, AnnouncementTypeEnum announcementType, string question, string answer)
{
Trace.Assert(Context.PersonId.HasValue);
using (var uow = Update())
{
var da = new AnnouncementQnADataAccess(uow);
var annQnA = GetAnnouncementQnA(announcementQnAId);
// todo: think about security
if (!CanEditQuestion(annQnA, uow))
{
throw new ChalkableSecurityException();
}
annQnA.State = AnnouncementQnAState.Answered;
annQnA.Question = question;
if ((BaseSecurity.IsDistrictOrTeacher(Context)) && (!annQnA.AnswererRef.HasValue || annQnA.AnswererRef == Context.PersonId))
{
var answerer = new PersonDataAccess(uow).GetById(Context.PersonId.Value);
annQnA.Answerer = answerer;
annQnA.AnswererRef = answerer.Id;
annQnA.AnsweredTime = Context.NowSchoolTime;
annQnA.Answer = answer;
}
da.Update(annQnA);
uow.Commit();
var ann = ServiceLocator.GetAnnouncementService(announcementType).GetAnnouncementById(annQnA.AnnouncementRef);
bool visibleForStudent = (ann is LessonPlan && (ann as LessonPlan).VisibleForStudent) ||
(ann is ClassAnnouncement && (ann as ClassAnnouncement).VisibleForStudent) ||
(ann is AdminAnnouncement);
if (visibleForStudent)
{
ServiceLocator.NotificationService.AddAnnouncementNotificationAnswerToStudent(annQnA.Id, annQnA.AnnouncementRef, announcementType);
}
return(annQnA);
}
}
private CardColor GetCardColor(AnnouncementTypeEnum type)
{
CardColor trump = 0;
switch (type)
{
case AnnouncementTypeEnum.Spades:
trump = CardColor.Spades;
break;
case AnnouncementTypeEnum.Hearts:
trump = CardColor.Hearts;
break;
case AnnouncementTypeEnum.Diamonds:
trump = CardColor.Diamonds;
break;
case AnnouncementTypeEnum.Clubs:
trump = CardColor.Clubs;
break;
}
return(trump);
}
public AnnouncementAttachment UploadAttachment(int announcementId, AnnouncementTypeEnum type, byte[] content, string name)
{
var annDetails = ServiceLocator.GetAnnouncementService(type).GetAnnouncementDetails(announcementId);
Trace.Assert(Context.PersonId.HasValue);
Trace.Assert(Context.SchoolLocalId.HasValue);
if (!CanAttach(annDetails))
{
throw new ChalkableSecurityException();
}
using (var uow = Update())
{
var att = AttachmentService.Upload(name, content, false, uow, ServiceLocator, ConnectorLocator);
var annAtt = new AnnouncementAttachment
{
AnnouncementRef = annDetails.Id,
AttachedDate = Context.NowSchoolTime,
Order = ServiceLocator.GetAnnouncementService(type).GetNewAnnouncementItemOrder(annDetails),
AttachmentRef = att.Id,
};
var da = new AnnouncementAttachmentDataAccess(uow);
var attId = da.InsertWithEntityId(annAtt);
uow.Commit();
bool notifyUsers = !annDetails.IsOwner ||
(annDetails.ClassAnnouncementData != null && annDetails.ClassAnnouncementData.VisibleForStudent) ||
(annDetails.LessonPlanData != null && annDetails.LessonPlanData.VisibleForStudent) ||
annDetails.AdminAnnouncementData != null;
if (notifyUsers)
{
NotifyUsers(annDetails, type);
}
return(da.GetById(attId, Context.PersonId.Value, Context.RoleId, true));
}
}
public Announcement RemoveFromAnnouncement(int announcementAppId, AnnouncementTypeEnum type)
{
try
{
using (var uow = Update())
{
var da = new AnnouncementApplicationDataAccess(uow);
var aa = da.GetById(announcementAppId);
var res = ServiceLocator.GetAnnouncementService(type).GetAnnouncementById(aa.AnnouncementRef);
if (!res.IsOwner && Context.Role != CoreRoles.DISTRICT_ADMIN_ROLE)
{
throw new ChalkableSecurityException(ChlkResources.ERR_SECURITY_EXCEPTION);
}
da.Delete(announcementAppId);
uow.Commit();
return(res);
}
}
catch
{
throw new ChalkableException(string.Format(ChlkResources.ERR_CANT_DELETE_ANNOUNCEMENT_APPLICATION, announcementAppId));
}
}
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);
});
}
}
public AttributeAttachmentContentInfo GetAttributeAttachmentContent(int assignedAttributeId, AnnouncementTypeEnum announcementType)
{
throw new System.NotImplementedException();
}
private CardColor GetCardColor( AnnouncementTypeEnum type )
{
CardColor trump = 0;
switch ( type )
{
case AnnouncementTypeEnum.Spades:
trump = CardColor.Spades;
break;
case AnnouncementTypeEnum.Hearts:
trump = CardColor.Hearts;
break;
case AnnouncementTypeEnum.Diamonds:
trump = CardColor.Diamonds;
break;
case AnnouncementTypeEnum.Clubs:
trump = CardColor.Clubs;
break;
}
return trump;
}
/// <summary>
/// Creates a new announcement
/// </summary>
public Announcement( AnnouncementTypeEnum type, bool isDoubled, bool isReDoubled )
{
_type = type;
_isDoubled = isDoubled;
_isReDoubled = isReDoubled;
}
private int CompareTo( AnnouncementTypeEnum type )
{
int x = 0, y = 0;
switch( this._type )
{
case AnnouncementTypeEnum.AllTrumps:
x = 7;
break;
case AnnouncementTypeEnum.NoTrumps:
x = 6;
break;
case AnnouncementTypeEnum.Spades:
x = 5;
break;
case AnnouncementTypeEnum.Hearts:
x = 4;
break;
case AnnouncementTypeEnum.Diamonds:
x = 3;
break;
case AnnouncementTypeEnum.Clubs:
x = 2;
break;
case AnnouncementTypeEnum.Pass:
x = 1;
break;
}
switch( type )
{
case AnnouncementTypeEnum.AllTrumps:
y = 7;
break;
case AnnouncementTypeEnum.NoTrumps:
y = 6;
break;
case AnnouncementTypeEnum.Spades:
y = 5;
break;
case AnnouncementTypeEnum.Hearts:
y = 4;
break;
case AnnouncementTypeEnum.Diamonds:
y = 3;
break;
case AnnouncementTypeEnum.Clubs:
y = 2;
break;
case AnnouncementTypeEnum.Pass:
y = 1;
break;
}
if( x > y )
return 1;
else if( x < y )
return -1;
else
return 0;
}
/// <summary>
/// If announcement made by this player is valid according to game rules
/// </summary>
public bool IsValid( Player player, AnnouncementTypeEnum type, bool isDoubled, bool isRedoubled )
{
//no player
if( player == null)
throw new ArgumentNullException( "Player", "Bidding player cannot be null");
//legal pass
if( type == AnnouncementTypeEnum.Pass )
{
if( !isDoubled && !isRedoubled )
return true;
else
return false;
}
if( _lastValidAnnouncement.CompareTo( type ) < 0 && !isDoubled && !isRedoubled )
return true;
if( _lastValidAnnouncement.CompareTo( type ) == 0 && !IsLastValidBidByTeam( player ) && !_lastValidAnnouncement.IsReDoubled)
{
if( !_lastValidAnnouncement.IsDoubled && isDoubled && !isRedoubled )
return true;
if( _lastValidAnnouncement.IsDoubled && !isDoubled && isRedoubled )
return true;
}
return false;
}
public Announcement Add(int announcementId, AnnouncementTypeEnum type, int attachmentId)
{
throw new NotImplementedException();
}
/// <summary>
/// Constructor for the class. Creates a new CardComparer object.
/// </summary>
/// <param name="announcementType"></param>
public CardComparer( AnnouncementTypeEnum announcementType )
{
this._announcementType = announcementType;
_isComparingCombinations = false;
}
public AnnouncementAttachment UploadAttachment(int announcementId, AnnouncementTypeEnum type, byte[] content, string name)
{
throw new NotImplementedException();
}
/// <summary>
/// Constructor for the class. Creates a new CardComparer object.
/// Compares in such order 7,8,9,10,J,Q,K,A
/// </summary>
internal CardComparer( )
{
this._announcementType = AnnouncementTypeEnum.Pass;
_isComparingCombinations = true;
}
