使用 Groovy 合并 MSN 聊天记录

1: import groovy.xml.*

   2: import java.text.*

   3:? 

   4: // History对应包含着多个MSN日志文件（xml）的目录。

   5: class History {

   6:     final folder,logs = []

   8:     def History(folder) {

   9:         this.folder = folder

  10:         folder.eachFileMatch(~/.*/.xml/) { logs << new Log(it) }     

  11:     }

  12:     

  13:     def merge(other) {

  14:         other.logs.each { log ->

  15:             def bak = logs.find { it.account == log.account }

  16:             if(bak) { bak.merge(log) } else logs << log

  17:         }

  18:     }

  19:     

  20:     def saveTo(folder) {

  21:         if(!folder.exists()) folder.mkdir()

  22:         assert folder.isDirectory()

  23:         logs.each { it.saveTo(folder) }

  24:     }    

  25:     def save() { saveTo(folder) }

  26: }

  27:? 

  28: class Util {

  29:     static builder = {

  30:         def builder = new StreamingMarkupBuilder()

  31:         builder.encoding = 'UTF-8'

  32:         builder

  33:     }

  34:     

  35:     static export(binding) {        

  36:         def builder = builder()

  37:         builder.bind(binding)

  38:     }

  39: }

  40:? 

  41: // Log对应单个的xml文件

  42: class Log {

  43:     final account // 文件名（hash过的MSN帐号）

  44:     def sessions

  45:     def Log(file) {

  46:         account = file.name - '.xml'

  47:         sessions = groupSessions(new XmlSlurper().parse(file))

  48:     }

  49:     

  50:     String export() {

  51:         def log = {

  52:             mkp.xmlDeclaration()

  53:             mkp.pi('xml-stylesheet': "type='text/xsl' href='MessageLog.xsl'")

  54:             Log(FirstSessionID: 1,LastSessionID: sessions.size()) {

  55:                 sessions.sort().eachWithIndex { session,index ->

  56:                     unescaped << session.export(index)

  57:                 }

  58:             }

  59:         }

  60:         Util.export(log)

  61:     }

  62:     

  63:     def merge(log) {

  64:         assert log.account == account

  65:         log.sessions.each { if(!sessions.contains(it)) sessions << it }   

  66:     }

  67:     

  68:     def saveTo(folder) {

  69:         new File(folder,"${account}.xml").write(export())

  70:     }

  71:     

  72:     //这里把文件中解析到不同的session。Session仅仅影响到日志的显示格式（背景颜色），不分也没有关系

  73:     private groupSessions(node) {

  74:         def list = []

  75:         node.children().each { list << it }      

  76:         list = list.groupBy { it.@SessionID.text() }.values()

  77:         //这里仅仅处理5种不同的实体类型，可能存在其它的类型

  78:         list.collect { nodes ->

  79:             new Session(sections: nodes.collect {                

  80:                 switch(it.name()) {

  81:                     case ['Leave','Join']:

  82:                         new Participation(it)

  83:                         break

  84:                     case ['InvitationResponse','Invitation']:

  85:                         new Invitation(it)

  86:                         break

  87:                     case 'Message':

  88:                         new Message(it)

  89:                         break

  90:                     default:

  91:                         throw new IllegalStateException("Unexpected name: ${ it.name() }")

  92:                 }

  93:             })

  94:         }

  95:     }  

  96: }

  97:? 

  98: //一组对话（也就是开着聊天窗口不断聊，只要不关闭窗口或断线就算一个会话

  99: class Session implements Comparable {

 100:     def sections

 101:     

 102:     def export(index) { sections.collect { it.export(index) }.join() }  

 103:     

 104:     // Session的日期时间即第一个消息的时间，仅供比较排序用

 105:     def getDate() { sections ? sections[0].date : null }

 106:     

 107:     int compareTo(other) { date?.compareTo(other?.date) }    

 108:     

 109:     // 这里的判断比较阳春。只有在两个Session的结构完全相同的情况下才返回true。但是在最近几个版本的MSN里都有

 110:     // 多点登录的功能。如果一台机器始终处于登录状态，另一台机器则是断断续续的登录，则同一段会话在两台机器上会

 111:     // 被记录为不同的Session。通过时间比对是不现实的，因为MSN记录的是本机时间，所以误差会影响判断。只能结合

 112:     // 时间和内容猜测两组Session是否对应着同一段会话，但计算成本会很高，就备份MSN日志这样的应用来说犯不着。

 113:     boolean equals(obj) { obj && obj instanceof Session && obj.sections == sections }

 114:     int hashCode() { sections.hashCode() }    

 115: }

 116:? 

 117: //对应每一条具体的消息片段

 118: abstract class Section {

 119:     def node,date,text,name

 120:     def init(node) {

 121:         this.node = node

 122:         name = node.name()

 123:         date = new LogDate(node.@DateTime.text())

 124:         text = new Text(node.Text.text(),node.Text.@Style.text())

 125:     }

 126:     

 127:     def prefix = ''

 128:     def suffix = ''

 129:       

 130:     def export(index) {

 131:         def section = {

 132:             "$name"(Date: date.date,Time: date.time,DateTime: date.datetime,SessionID: index + 1) {

 133:                 unescaped << prefix

 134:                 Text(Style: text.style) { out << text.content }

 135:                 unescaped << suffix

 136:             }

 137:         }

 138:         Util.export(section)

 139:     }

 140:     

 141:     boolean equals(obj) { obj && obj instanceof Section && obj.name == name && obj.text == text }

 142:     int hashCode() { text.hashCode() }

 143: }

 144:? 

 145: // 用于表述日志中的日期格式

 146: // 本来这个类没有那么复杂，但是看到其中的DateTime格式后，我强烈怀疑MSN的代码有问题，应该是格式字符串给弄错了

 147: // 长日期格式的最后应该是时区，但是日志中却是代表时区格式的'Z'字符，应该是MS的程序员多写了一对单引号吧。

 148: // 最初我是拿DateTime的字符串直接截取成Date和Time，结果发现时区偏移了8小时……于是一冲动就玩了把日期解析。

 149: // 其实简单的做法应该是直接从xml里读取全部的三个参数，那样完全可以少写7行代码的:(

 150: // 安慰自己下，这样的话至少可以检测出日志里错误的日期格式啊

 151: class LogDate implements Comparable {

 152:     private static final timezone = TimeZone.getTimeZone('Asia/Shanghai')

 153:     private static final dtf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")

 154:     private static final df = new SimpleDateFormat('yyyy-MM-dd')

 155:     private static final tf = new SimpleDateFormat('HH:mm:ss')

 156:     final String datetime,time

 157:     def LogDate(datetime) {

 158:         this.datetime = datetime

 159:         def d = dtf.parse(datetime)  

 160:         d = new Date(d.time - timezone.getOffset(d.time))

 161:         date = df.format(d)

 162:         time = tf.format(d)      

 163:     }

 164:     

 165:     int compareTo(other) { datetime.compareTo(other?.datetime) }

 166: }

 167:? 

 168: class Text {

 169:     final content,style

 170:     def Text(content,style) {

 171:         this.content = content

 172:         this.style = style

 173:     }

 174:     boolean equals(obj) {

 175:         obj && obj instanceof Text && content == obj.content && style == obj.style

 176:     }

 177:     int hashCode() { content.hashCode() }

 178: }

 179:? 

 180: class User {

 181:     final friendlyName

 182:     def User(friendlyName) {

 183:         this.friendlyName = friendlyName

 184:     }    

 185:     def export() { Util.export({ User(FriendlyName: friendlyName) }) }

 186: }

 187:? 

 188: class UserList {

 189:     final type,users = []

 190:     def UserList(node) {

 191:         type = node.name()

 192:         node.children().each {

 193:             if(it.name() != 'User') throw new IllegalStateException("Unexpected name: ${it.name}")

 194:             users << new User(it.@FriendlyName.text())

 195:         }

 196:     }

 197:     

 198:     def export() { """<$type>${users.collect{ it.export() }.join()}""" }

 199: }

 200:? 

 201: // 群聊的时候用户加入和离开的信息

 202: class Participation extends Section {

 203:     def user

 204:     def Participation(node) {

 205:         init(node)

 206:         user = new User(node.User.@FriendlyName.text())

 207:     }

 208:     

 209:     String getPrefix() { user.export() }

 210: }

 211:? 

 212: class Message extends Section {

 213:     def from,to

 214:     def Message(node) {

 215:         init(node)

 216:         node.children().each { child ->

 217:             switch(child.name()) {

 218:                 case 'Text': break

 219:                 case 'To': to = new UserList(child); break

 220:                 case 'From': from = new UserList(child); break

 221:                 default: throw new IllegalStateException("Unexpected name: ${child.name}")

 222:             }    

 223:         }    

 224:     } 

 225:     

 226:     String getSuffix() { "${to.export()}${from.export()}" }

 227: }

 228:? 

 229: // 文件邀请、视频邀请的记录

 230: class Invitation extends Section {

 231:     def from,contents = [:]

 232:     def Invitation(node) {

 233:         init(node)        

 234:         node.children().each { child ->

 235:             switch(child.name()) {

 236:                 case 'Text': break

 237:                 case 'From': from = new UserList(child); break

 238:                 default: contents.put(child.name(),child.text())

 239:             }

 240:         }        

 241:     }

 242:     

 243:     String getSuffix() {

 244:         """${contents.collect { key,value -> Util.export({ "$key" { out << value } }) }.join()}${from.export()}"""

 245:     }

 246: }

 247:? 

 248: //-----------------------------------------------------------------

 249: // 待整合的文件目录（该目录下的文件不会发生变化）

 250: path = '/home/hiarcs/deep_crazy4057207345/History'

 251: // 整合目标（对应的文件将变大）

 252: backup = new History(new File('/home/hiarcs/msn'))

 253:? 

 254: folder = new File(path)

 255: history = new History(folder)

 256:? 

 257: backup.merge(history)

 258: backup.save()

 259: 'Done'