public Member(Grace.Models.Member member)
{
MemberModel = member;
if (member.MemberID != 0)
{
if (member.MemberRelations.Count > 0)
{
HeadOfHousehold = "Self";
HeadMemberID = member.MemberID;
MemberRelations = member.MemberRelations.ToList();
}
else
{
if (member.MemberRelations1.Count > 0)
{
HeadOfHousehold = member.MemberRelations1[0].Member.FullName;
HeadMemberID = member.MemberRelations1[0].HeadMemberID;
MemberRelations = member.MemberRelations1[0].Member.MemberRelations.ToList();
}
else
{
HeadOfHousehold = "Self";
HeadMemberID = member.MemberID;
MemberRelations = member.MemberRelations1.ToList();
}
}
}
}
public override bool StartSpecialSkill(Cooldown sk)
{
if (sk.Skill.IconName == EnergyStars.Cooldown.Skill.IconName)
{
EnergyStars.StartCooldown(sk.Duration);
return(true);
}
if (sk.Skill.IconName == Grace.Cooldown.Skill.IconName)
{
Grace.StartCooldown(sk.Duration);
return(true);
}
if (sk.Skill.IconName == EdictOfJudgment.Cooldown.Skill.IconName)
{
EdictOfJudgment.StartCooldown(sk.Duration);
return(true);
}
if (sk.Skill.IconName == DivineCharge.Cooldown.Skill.IconName)
{
DivineCharge.StartCooldown(sk.Duration);
return(true);
}
if (sk.Skill.IconName != TripleNemesis.Cooldown.Skill.IconName)
{
return(false);
}
TripleNemesis.StartCooldown(sk.Duration);
return(true);
}
public override void Dispose()
{
Grace.Dispose();
EdictOfJudgment.Dispose();
DivineCharge.Dispose();
TripleNemesis.Dispose();
}
private static void CheckGrace(S_ABNORMALITY_END p)
{
if (p.AbnormalityId != GraceId)
{
return;
}
if (!IsViewModelAvailable <PriestLayoutVM>(out var vm))
{
return;
}
vm !.Grace.StopEffect();
}
private static void CheckGrace(S_ABNORMALITY_REFRESH p)
{
if (p.AbnormalityId != GraceId)
{
return;
}
if (!IsViewModelAvailable <PriestLayoutVM>(out var vm))
{
return;
}
vm !.Grace.RefreshEffect(p.Duration);
}
public ActionResult Create(Grace.ViewModels.SSClassTeacher ssClassTeacher)
{
if (TryValidateModel(ssClassTeacher.SSClassTeacherModel))
try
{
_repository.Add(ssClassTeacher.SSClassTeacherModel);
return RedirectToAction(Config.ActionVariables.Edit, Config.ControllerVariables.SSClass, new { id = ssClassTeacher.SSClassTeacherModel.SSClassID });
}
catch
{
return View(ssClassTeacher);
}
else
return View(ssClassTeacher);
}
public ActionResult Create(Grace.ViewModels.Member member)
{
if (TryValidateModel(member.MemberModel))
try
{
_repository.Add(member.MemberModel);
return RedirectToAction(Config.ActionVariables.Index);
}
catch
{
return View(member);
}
else
return View(member);
}
public ActionResult Create(Grace.Models.Committee committee)
{
if (ModelState.IsValid)
try
{
_repository.Add(committee);
return RedirectToAction(Config.ActionVariables.Index);
}
catch
{
return View(committee);
}
else
return View(committee);
}
public ActionResult Create(Grace.ViewModels.CommitteeMember committeeMember)
{
if (TryValidateModel(committeeMember.CommitteeMemberModel))
try
{
_repository.Add(committeeMember.CommitteeMemberModel);
return RedirectToAction(Config.ActionVariables.Edit, Config.ControllerVariables.Committee, new { id = committeeMember.CommitteeMemberModel.CommitteeID });
}
catch
{
return View(committeeMember);
}
else
return View(committeeMember);
}
public ActionResult Create(Grace.ViewModels.MemberRelation memberRelation)
{
if (TryValidateModel(memberRelation.MemberRelationModel))
try
{
_repository.Add(memberRelation.MemberRelationModel);
return RedirectToAction(Config.ActionVariables.Edit, Config.ControllerVariables.Member, new {id=memberRelation.MemberRelationModel.HeadMemberID});
}
catch
{
return View(memberRelation);
}
else
return View(memberRelation);
}
partial void DeleteSSClassTeacher(Grace.Models.SSClassTeacher instance);
partial void InsertSSClassMember(Grace.Models.SSClassMember instance);
partial void UpdateSSClass(Grace.Models.SSClass instance);
partial void DeleteSSAttendance(Grace.Models.SSAttendance instance);
partial void InsertSSAttendance(Grace.Models.SSAttendance instance);
partial void UpdateService(Grace.Models.Service instance);
partial void DeletePersonnelMember(Grace.Models.PersonnelMember instance);
partial void DeletePersonnel(Grace.Models.Personnel instance);
partial void InsertPersonnel(Grace.Models.Personnel instance);
partial void UpdatePersonnel(Grace.Models.Personnel instance);
/// <summary>
/// Process a detected deletion.
/// </summary>
/// <param name="remoteFolder">Remote folder.</param>
/// <param name="localFolder">Local folder.</param>
/// <param name="pathname">Pathname.</param>
/// <returns>Whether the delete has now been synchronized, so that no further action is needed</returns>
private bool WatcherSyncDelete(string remoteFolder, string localFolder, string pathname, Grace grace)
{
SleepWhileSuspended();
// In many programs (like Microsoft Word), deletion is often just a save:
// 1. Save data to temporary file ~wrdxxxx.tmp
// 2. Delete Example.doc
// 3. Rename ~wrdxxxx.tmp to Example.doc
// See https://support.microsoft.com/en-us/kb/211632
// So, upon deletion, wait a bit for any save operation to hopefully finalize, then sync.
// This is not 100% foolproof, as saving can last for more than the grace time, but probably
// the best we can do without mind-reading third-party programs.
grace.WaitGraceTime();
try
{
if (Utils.IsMetadataFile(pathname))
{
// Nothing to do
return(true);
}
SyncItem item = database.GetSyncItemFromLocalPath(pathname);
if (item == null)
{
// The item must be in the database
return(false);
}
ICmisObject cmisObject = session.GetObjectByPath(item.RemotePath);
if (cmisObject == null)
{
// the object does not exist on the server so nothing to do
return(true);
}
cmisObject.Delete(true);
// Folder or File
database.RemoveFolder(item);
database.RemoveFile(item);
// Remove metadata if exists
if (File.Exists(pathname + ".metadata"))
{
File.Delete(pathname + ".metadata");
database.RemoveMetadataFile(item);
}
return(true);
}
catch (Exception e)
{
ProcessRecoverableException("Could Not process Watch Sync Delete : ", e);
return(false);
}
}
partial void InsertPersonnelMember(Grace.Models.PersonnelMember instance);
/// <summary>
/// An event was received from the filesystem watcher, analyze the change and apply it.
/// <returns>Whether the move has now been synchronized, so that no further action is needed</returns>
/// </summary>
private bool WatchSyncMove(string remoteFolder, string localFolder, string oldPathname, string newPathname, Grace grace)
{
bool success = true;
SleepWhileSuspended();
try
{
// Old item.
string oldDirectory = Path.GetDirectoryName(oldPathname);
string oldFilename = Path.GetFileName(oldPathname);
string oldLocalName = oldPathname.Substring(localFolder.Length + 1);
SyncItem oldItem = database.GetSyncItemFromLocalPath(oldPathname);
if (oldItem == null)
{
// The change is about a file which was not in database yet, we can't move it. Further action is needed.
return(false);
}
string oldRemoteName = oldItem.RemotePath;
string oldRemoteBaseName = CmisUtils.GetUpperFolderOfCmisPath(oldRemoteName);
bool oldPathnameWorthSyncing = Utils.WorthSyncing(oldDirectory, oldFilename, repoInfo);
// New item.
bool isFolder = Utils.IsFolder(newPathname);
string newDirectory = Path.GetDirectoryName(newPathname); // TODO do this only if isFolder is true, modify rest of the logic accordingly.
string newFilename = Path.GetFileName(newPathname);
string newLocalName = newPathname.Substring(localFolder.Length + 1);
SyncItem newItem = SyncItemFactory.CreateFromLocalPath(newPathname, isFolder, repoInfo, database);
string newRemoteName = newItem.RemotePath;
string newRemoteBaseName = CmisUtils.GetUpperFolderOfCmisPath(newRemoteName);
bool newPathnameWorthSyncing = Utils.WorthSyncing(newDirectory, newFilename, repoInfo);
// Operations.
bool rename = oldDirectory.Equals(newDirectory) && !oldFilename.Equals(newFilename);
bool move = !oldDirectory.Equals(newDirectory) && oldFilename.Equals(newFilename);
if ((rename && move) || (!rename && !move))
{
Logger.ErrorFormat("Not a valid rename/move: {0} -> {1}", oldPathname, newPathname);
return(true); // It is not our problem that watcher data is not valid.
}
if (oldPathnameWorthSyncing && newPathnameWorthSyncing)
{
if (database.ContainsLocalFile(oldPathname))
{
if (database.ContainsLocalFile(newPathname))
{
//database already contains path so revert back to delete/update
success &= WatcherSyncDelete(remoteFolder, localFolder, oldPathname, grace);
success &= WatcherSyncUpdate(remoteFolder, localFolder, newPathname);
}
else
{
if (rename)
{
//rename file...
IDocument remoteDocument = (IDocument)session.GetObjectByPath(oldRemoteName);
success &= RenameFile(oldDirectory, newFilename, remoteDocument);
}
else //move
{
//move file...
IDocument remoteDocument = (IDocument)session.GetObjectByPath(oldRemoteName);
IFolder oldRemoteFolder = (IFolder)session.GetObjectByPath(oldRemoteBaseName);
IFolder newRemoteFolder = (IFolder)session.GetObjectByPath(newRemoteBaseName);
success &= MoveFile(oldDirectory, newDirectory, oldRemoteFolder, newRemoteFolder, remoteDocument);
}
}
}
else if (database.ContainsFolder(oldPathname))
{
if (database.ContainsFolder(newPathname))
{
//database already contains path so revert back to delete/update
success &= WatcherSyncDelete(remoteFolder, localFolder, oldPathname, grace);
success &= WatcherSyncUpdate(remoteFolder, localFolder, newPathname);
}
else
{
if (rename)
{
//rename folder...
IFolder remoteFolderObject = (IFolder)session.GetObjectByPath(oldRemoteName);
success &= RenameFolder(oldDirectory, newFilename, remoteFolderObject);
}
else //move
{
//move folder...
IFolder remoteFolderObject = (IFolder)session.GetObjectByPath(oldRemoteName);
IFolder oldRemoteFolder = (IFolder)session.GetObjectByPath(oldRemoteBaseName);
IFolder newRemoteFolder = (IFolder)session.GetObjectByPath(newRemoteBaseName);
success &= MoveFolder(oldDirectory, newDirectory, oldRemoteFolder, newRemoteFolder, remoteFolderObject);
}
}
}
else
{
//File/Folder has not been synced before so simply update
success &= WatcherSyncUpdate(remoteFolder, localFolder, newPathname);
}
}
else if (oldPathnameWorthSyncing && !newPathnameWorthSyncing)
{
//New path not worth syncing
success &= WatcherSyncDelete(remoteFolder, localFolder, oldPathname, grace);
}
else if (!oldPathnameWorthSyncing && newPathnameWorthSyncing)
{
//Old path not worth syncing
success &= WatcherSyncUpdate(remoteFolder, localFolder, newPathname);
}
else
{
//Neither old or new path worth syncing
}
}
catch (FileNotFoundException e)
{
success = false;
Logger.Warn("Could process watcher sync move, file or folder not found: " + oldPathname + " -> " + newPathname, e);
}
catch (Exception e)
{
success = false;
ProcessRecoverableException("Could not process watcher sync move: " + oldPathname + " -> " + newPathname, e);
}
return(success);
}
partial void InsertService(Grace.Models.Service instance);
/// <summary>
/// Process a detected deletion.
/// </summary>
/// <param name="remoteFolder">Remote folder.</param>
/// <param name="localFolder">Local folder.</param>
/// <param name="pathname">Pathname.</param>
/// <returns>Whether the delete has now been synchronized, so that no further action is needed</returns>
private bool WatcherSyncDelete(string remoteFolder, string localFolder, string pathname, Grace grace)
{
SleepWhileSuspended();
// In many programs (like Microsoft Word), deletion is often just a save:
// 1. Save data to temporary file ~wrdxxxx.tmp
// 2. Delete Example.doc
// 3. Rename ~wrdxxxx.tmp to Example.doc
// See https://support.microsoft.com/en-us/kb/211632
// So, upon deletion, wait a bit for any save operation to hopefully finalize, then sync.
// This is not 100% foolproof, as saving can last for more than the grace time, but probably
// the best we can do without mind-reading third-party programs.
grace.WaitGraceTime();
return(false); // Perform a sync.
}
partial void DeleteService(Grace.Models.Service instance);
partial void InsertPastor(Grace.Models.Pastor instance);
partial void UpdateSSAttendance(Grace.Models.SSAttendance instance);
partial void UpdatePastor(Grace.Models.Pastor instance);
partial void InsertSSClass(Grace.Models.SSClass instance);
partial void DeletePastor(Grace.Models.Pastor instance);
partial void DeleteSSClass(Grace.Models.SSClass instance);
partial void InsertPastorType(Grace.Models.PastorType instance);
partial void DeleteSSClassMember(Grace.Models.SSClassMember instance);
partial void UpdatePastorType(Grace.Models.PastorType instance);
partial void InsertSSClassTeacherType(Grace.Models.SSClassTeacherType instance);
partial void DeletePastorType(Grace.Models.PastorType instance);
