/// <summary>
/// Aggiunge i dati del documento nella coda dei processi
/// </summary>
/// <param name="DMD"></param>
void AddMessageNotificationQueue(DocumentMonitorData Data)
{
lock (lockQueue)
{
#if (DEBUG)
{
Console.WriteLine("Aggiunto in coda " + Data.FullFileName);
}
#endif
messageNotificationQueue.Enqueue(Data);
}
}
/// <summary>
/// spedisce la notifica
/// </summary>
/// <param name="Message"></param>
public void SendsNotification(DocumentMonitorData Message)
{
// nessuna regola matcha esce
if (Message.IndexFile == 0)
{
return;
}
// effettua il refresh del login di present dal PRP
CheckLoggedTime();
if (context == null)
{
logger.Warn("PresentDataContext is null SendsNotification failed!");
return;
}
// imposta il messaggio da notificare nel documento
var notifyMessage = ResourceDecodeMessage(Message);
// il messaggio per essere valido deve avere il testo e il soggetto
if (notifyMessage.Subject == string.Empty || notifyMessage.Text == string.Empty)
{
return;
}
switch (Message.FileState)
{
case eFileState.CreatedOrChanged:
var log = string.Empty;
var messageFound = false;
if (Message.isPublicMessage)
{
// la notifica è pubblica per cui il targetAccoutID è 0
// cancella eventuale notifica precedente se UpdateMessage
messageFound = RemoveMessage(0, param.UpdateMessage, notifyMessage);
// se trova un messaggio precedente e non è impostato il flag UpdateMessage NON inserisce la nuova notifica
if ((!messageFound && !param.UpdateMessage) || param.UpdateMessage)
{
PushMessage(0, notifyMessage);
log = string.Format("inserita notifica pubblica {0}", Message.FullFileName);
}
else
{
log = string.Format("notifica globale pubblica {0}", Message.FullFileName);
}
logger.Info(log);
}
else
{
// piu utenti web possono avere associato un utente present effettua le notifiche a tutti gli utenti web
GetAccountID(Message.Value).ForEach(targetAccountId =>
{
// cancella eventuale notifica precedente se UpdateMessage
messageFound = RemoveMessage(targetAccountId, param.UpdateMessage, notifyMessage);
// se trova un messaggio precedente e non è impostato il flag UpdateMessage NON inserisce la nuova notifica
if ((!messageFound && !param.UpdateMessage) || param.UpdateMessage)
{
PushMessage(targetAccountId, notifyMessage);
log = string.Format("inserita notifica {0} {1} {2} accountID {3}", Message.FullFileName, param.PersonKeyField, Message.Value, targetAccountId);
}
else
{
log = string.Format("notifica trovata {0} {1} {2} accountID {3}", Message.FullFileName, param.PersonKeyField, Message.Value, targetAccountId);
}
logger.Info(log);
});
}
break;
case eFileState.Deleted:
if (Message.isPublicMessage)
{
// la notifica è pubblica per cui il targetAccoutID è 0
RemoveMessage(0, true, notifyMessage);
log = string.Format("rimossa notifica pubblica {0}", Message.FullFileName);
logger.Info(log);
}
else
{
// piu utenti web possono avere associato un utente present effettua le notifiche a tutti gli utenti web
GetAccountID(Message.Value).ForEach(targetAccountId =>
{
// se non c'è + il documento lo cancella
RemoveMessage(targetAccountId, true, notifyMessage);
log = string.Format("rimossa notifica {0} {1} {2} accountID {3}", Message.FullFileName, param.PersonKeyField, Message.Value, targetAccountId);
logger.Info(log);
});
}
break;
case eFileState.Renamed:
var oldLog = string.Empty;
if (Message.isPublicMessage)
{
// la notifica è pubblica per cui il targetAccoutID è 0
oldLog = string.Format("rinominata notifica pubblica {0} in {1}", Message.OldFullFileName, Message.FullFileName);
logger.Info(oldLog);
// cancella la vecchia notifica rinominata
RemoveMessage(0, true, notifyMessage);
oldLog = string.Format("rimossa notifica pubblica {0}", Message.OldFullFileName);
logger.Info(oldLog);
// cancella eventuale notifica rinominata precedente se UpdateMessage
messageFound = RemoveMessage(0, param.UpdateMessage, notifyMessage);
// se trova un messaggio precedente e non è impostato il flag UpdateMessage NON inserisce la nuova notifica
if ((!messageFound && !param.UpdateMessage) || param.UpdateMessage)
{
PushMessage(0, notifyMessage);
log = string.Format("inserita notifica pubblica {0}", Message.FullFileName);
logger.Info(log);
}
else
{
log = string.Format("notifica trovata pubblica {0}", Message.FullFileName);
}
}
else
{
// notifica privata
oldLog = string.Format("rinominata notifica {0} in {1} {2} {3}", Message.OldFullFileName, Message.FullFileName, param.PersonKeyField, Message.OldValue);
logger.Info(oldLog);
// piu utenti web possono avere associato un utente present effettua le notifiche a tutti gli utenti web
GetAccountID(Message.OldValue).ForEach(oldTargetAccountId =>
{
// se non c'è + il documento lo cancella
RemoveMessage(oldTargetAccountId, true, notifyMessage);
oldLog = string.Format("rimossa notifica {0} {1} {2} accountID {3}", Message.OldFullFileName, param.PersonKeyField, Message.OldValue, oldTargetAccountId);
logger.Info(oldLog);
});
// piu utenti web possono avere associato un utente present effettua le notifiche a tutti gli utenti web
GetAccountID(Message.Value).ForEach(targetAccountId =>
{
// cancella eventuale notifica precedente se UpdateMessage
messageFound = RemoveMessage(targetAccountId, param.UpdateMessage, notifyMessage);
// se trova un messaggio precedente e non è impostato il flag UpdateMessage NON inserisce la nuova notifica
if ((!messageFound && !param.UpdateMessage) || param.UpdateMessage)
{
PushMessage(targetAccountId, notifyMessage);
log = string.Format("inserita notifica {0} {1} {2} accountID {3}", Message.FullFileName, param.PersonKeyField, Message.Value, targetAccountId);
logger.Info(log);
}
else
{
log = string.Format("notifica trovata {0} {1} {2} accountID {3}", Message.FullFileName, param.PersonKeyField, Message.Value, targetAccountId);
}
});
}
break;
case eFileState.None:
break;
default:
break;
}
}
/// <summary>
/// decodifica (dalle risorse) il soggetto ed il testo del messaggio
/// </summary>
/// <param name="Message"></param>
/// <param name="subject"></param>
/// <param name="text"></param>
/// <param name="oldText"></param>
private NotifyMessage ResourceDecodeMessage(DocumentMonitorData Message)
{
var notifyMessage = new NotifyMessage();
// messaggio pubblico / privato da decodificare in base alla lingua e opzionalmente alla data
try
{
var paramLanguage = param.LanguageKey.FirstOrDefault(Index => Index.IndexFile == Message.IndexFile);
string yearMonth = "";
if (Message.ReadYear)
{
yearMonth = " {1:yyyy}";
}
if (Message.ReadMonth)
{
yearMonth += " {1:MM}";
}
// versione 1.0.0.2 tredicesima e/o quattordicesima inserisce la stringa aggiuntiva EXTRA
var extra = "";
switch (Message.ExtraMonth)
{
case 1:
{
extra = " tredicesima";
break;
}
case 2:
{
extra = " quattordicesima";
break;
}
}
if (Message.ReadYear || Message.ReadMonth)
{
// messaggio con anno e mese
notifyMessage.Subject = string.Format("{0}" + extra + yearMonth, Resources.GetString(paramLanguage.Subject), Message.Period);
notifyMessage.Text = Resources.GetString(paramLanguage.Text, Message.FullFileName, Message.Period);
if (Message.OldFullFileName != "")
{
notifyMessage.OldText = Resources.GetString(paramLanguage.Text, Message.OldFullFileName, Message.Period);
}
}
else
{
// messaggio senza periodo o messaggio globale
// qui il programma è x forza un po' inchiodato perché nel segnaposto {1} abbiamo il nome del file
notifyMessage.Subject = Resources.GetString(paramLanguage.Subject);
notifyMessage.Text = Resources.GetString(paramLanguage.Text, Message.FullFileName, GetFileName(Message.FullFileName));
if (Message.OldFullFileName != "")
{
notifyMessage.OldText = Resources.GetString(paramLanguage.Text, Message.OldFullFileName, GetFileName(Message.OldFullFileName));
}
}
return(notifyMessage);
}
catch (Exception ex)
{
logger.Error(ex, string.Format("Errori nella decodifica del soggetto e/o del testo del messaggio da inserire"));
return(notifyMessage);
}
}
/// <summary>
/// estrae i dati dal nome del file
/// </summary>
/// <param name="FullFileName"></param>
/// <returns></returns>
DocumentMonitorData ExctractFileData(string FullFileName)
{
var attr = new DocumentMonitorData();
try
{
param.RegExFiles.ForEach(reg =>
{
var matchPeriod = Regex.Match(FullFileName, reg.FullFileNameRegEx, RegexOptions.IgnoreCase);
if (matchPeriod.Success)
{
attr.IndexFile = reg.IndexFile;
// dal nome viene estratto il periodo
int year = (reg.YearPosition > 0) ? Convert.ToInt32(matchPeriod.Groups[reg.YearPosition].Value) : 0;
int month = (reg.MonthPosition > 0) ? Convert.ToInt32(matchPeriod.Groups[reg.MonthPosition].Value) : 0;
//var month = (reg.MonthPosition > 0) ? Convert.ToInt32(matchPeriod.Groups[reg.MonthPosition].Value) : 1;
// dal nome del file viene estratta la chiave della persona
string key = (reg.KeyPosition > 0) ? Convert.ToInt64(matchPeriod.Groups[reg.KeyPosition].Value).ToString(param.FormatDipKey) : param.FormatDipKey;
attr.ReadMonth = (reg.MonthPosition > 0);
attr.ReadYear = (reg.YearPosition > 0);
attr.Value = key;
// versione 1.0.0.2 inseriscono i mesi con il 13 per la tredicesima e con il 14 per la quattordicesima
if (month > 12)
{
attr.ExtraMonth = month - 12;
// default reiserisce un mese valido
month = 12;
// prima leggeva il mese dagli attributi del file
//month = File.GetLastWriteTime(FullFileName).Month;
switch (attr.ExtraMonth)
{
case 1:
{
// mese tredicesima
if (param.ThirteenthMonth >= 1 && param.ThirteenthMonth <= 12)
{
month = param.ThirteenthMonth;
}
break;
}
case 2:
{
// mese quattordicesima
if (param.FourteenthMonth >= 1 && param.FourteenthMonth <= 12)
{
month = param.FourteenthMonth;
}
break;
}
}
}
if (attr.ReadMonth || attr.ReadYear)
{
// se il mese non è impostato setta di default gennaio
// solo perché non dia errore nella stringa del database localization estrae poi correttamente solo il mese o l'anno
if (!attr.ReadMonth)
{
month = 1;
}
// se l'anno non è impostato setta di default l'anno corrente
// solo perché non dia errore nella stringa del database localization estrae poi correttamente solo il mese o l'anno
if (!attr.ReadYear)
{
year = DateTime.Today.Year;
}
// imposta il periodo relativo al nome del file
attr.Period = new DateTime(year, month, 1);
}
// imposta se il messaggio è pubblico o privato
attr.isPublicMessage = reg.isPublicMessage;
}
});
}
catch
{
return(attr);
}
return(attr);
}