~openerp-syleam/+junk/extra-addons

'cc_to':fields.char('Send copy to', size=256, readonly=True, states={'new':[('readonly',False)]}, help="use comma to supply multiple address. email@domain.com, email2@domain.com"),

'bcc_to':fields.char('Send blind copy to', size=256, readonly=True, states={'new':[('readonly',False)]}, help="use comma to supply multiple address. email@domain.com, email2@domain.com"),

'user' : fields.char('User Name', size=256, readonly=True, states={'new':[('readonly',False)]}),

'password' : fields.char('Password', size=1024, invisible=True, readonly=True, states={'new':[('readonly',False)]}),

'server' : fields.char('SMTP Server', size=256, required=True, readonly=True, states={'new':[('readonly',False)]}),

'auth' : fields.boolean("Use Auth", readonly=True, states={'new':[('readonly',False)]}),

'port' : fields.char('SMTP Port', size=256, required=True, readonly=True, states={'new':[('readonly',False)]}),

'ssl' : fields.boolean("Use SSL?", readonly=True, states={'new':[('readonly',False)]}),

'users_id': fields.many2many('res.users', 'res_smtpserver_group_rel', 'sid', 'uid', 'Users Allowed'),

'state': fields.selection([

('new','Not Verified'),

('waiting','Waiting for Verification'),

('confirm','Verified'),

],'Server Status', select=True, readonly=True),

'auth_type':fields.selection([('gmail','Google Server'), ('yahoo','Yahoo!!! Server'), ('unknown','Other Mail Servers')], string="Server Type", readonly=True, states={'new':[('readonly',False)]}),

'active' : fields.boolean("Active"),

'date_create': fields.date('Date Create', required=True, readonly=True),

'test_email' : fields.text('Test Message', translate=True),

'body' : fields.text('Message', translate=True, help="The message text that will be send along with the email which is send through this server"),

'verify_email' : fields.text('Verify Message', translate=True, readonly=True, states={'new':[('readonly',False)]}),

'code' : fields.char('Verification Code', size=1024),

'type' : fields.selection([("default", "Default"),("account", "Account"),("sale","Sale"),("stock","Stock")], "Server Type",required=True),

'history_line': fields.one2many('email.smtpclient.history', 'server_id', 'History'),

'server_statistics': fields.one2many('report.smtp.server', 'server_id', 'Statistics'),

'delete_queue': fields.selection([

('never','Never Delete Message'),

('content','Delete Content After'),

('all','Clear All After'),

100

('after_send','Delete when Email Sent'),

101

],'Queue Option', select=True),

102

'priority': fields.integer('Server Priority', readonly=True, states={'new':[('readonly',False)]}, help="Priority between 0 to 10, will be used to define the MTA process priotiry"),

103

'header_ids':fields.one2many('email.headers', 'server_id', 'Default Headers'),

104

'disclaimers': fields.text('Disclaimers'),

105

'process_id': fields.many2one('ir.cron', 'MTA Process', readonly=True, help="Mail Transport Agent Process"),

106

'pstate': fields.selection([

107

('running','Running'),

108

('stop','Stop'),

109

],'Server Statue', select=True, readonly=True),

110

'delete_queue_period': fields.integer('Delete after', help="delete emails/contents from email queue after specified no of days"),

111

}

112

113

def _get_users(self, cr, uid, context={}):

114

return self.pool.get('res.users').search(cr, uid, [])

115

116

_defaults = {

117

'date_create': lambda *a: time.strftime('%Y-%m-%d'),

118

'state': lambda *a: 'new',

119

'type': lambda *a: 'default',

120

'port': lambda *a: '25',

121

'pstate':lambda *a: 'stop',

122

'priority': lambda *a: 5,

123

'delete_queue_period': lambda *a: 30,

124

'auth': lambda *a: True,

125

'active': lambda *a: True,

126

'delete_queue': lambda *a: 'never',

127

'users_id': _get_users,

128

'verify_email': lambda *a: _("Verification Message. This is the code\n\n__code__\n\nyou must copy in the OpenERP Email Server (Verify Server wizard).\n\nCreated by user __user__"),

129

}

130

131

server = {}

132

smtpServer = {}

133

134

def create(self, cr, user, vals, context={}):

135

if vals.get('password', False) != False:

136

vals['password'] = base64.b64encode(vals.get('password'))

137

138

res_id = super(smtpclient, self).create(cr, user, vals, context)

139

return res_id

140

141

def write(self, cr, user, ids, vals, context=None):

142

flag = False

143

if vals.get('password', False) != False:

144

for pass_char in vals.get('password'):

145

if pass_char != '*':

146

flag= True

147

break

148

149

if flag:

150

vals['password'] = base64.b64encode(vals.get('password'))

151

else:

152

del vals['password']

153

154

res = super(smtpclient, self).write(cr, user, ids, vals, context)

155

return res

156

157

def read(self,cr, uid, ids, fields=None, context=None, load='_classic_read'):

158

def override_password(o):

159

if len(o) > 0:

160

for field in o[0]:

161

if field == 'password':

162

o[0][field] = '********'

163

return o

164

165

result = super(smtpclient, self).read(cr, uid, ids, fields, context, load)

166

result = override_password(result)

167

return result

168

169

def change_servertype(self, cr, uid, ids, server):

170

if server == 'gmail':

171

return {'value':{'server':'smtp.gmail.com', 'port':'25', 'ssl':True, 'auth':True}}

172

elif server== 'yahoo':

173

return {'value':{'server':'smtp.mail.yahoo.co.in', 'ssl':False, 'port':'587', 'auth':True}}

174

else:

175

return {'value':{'server':'localhost', 'port':'25', 'ssl':False, 'auth':False}}

176

177

def change_email(self, cr, uid, ids, email):

178

email_from = self.pool.get('res.users').browse(cr, uid, uid).name

179

if len(email) > 0 and email.find('@') > -1 and email.index('@') > 0:

180

user = email[0:email.index('@')]

181

return {'value':{'user':user, 'from_email':email_from+' <'+email+'>'}}

182

else:

183

return {'value':{'user':email, 'from_email':email_from+' <'+email+'>'}}

184

185

def check_permissions(self, cr, uid, ids):

186

if uid == 1:

187

return True

188

cr.execute('select * from res_smtpserver_group_rel where sid=%s and uid=%s' % (ids[0], uid))

189

data = cr.fetchall()

190

if len(data) <= 0:

191

return False

192

193

return True

194

195

def gen_private_key(self, cr, uid, ids):

196

new_key = []

197

for i in time.strftime('%Y-%m-%d %H:%M:%S'):

198

ky = i

199

if ky in (' ', '-', ':'):

200

keys = random.random()

201

key = str(keys).split('.')[1]

202

ky = key

203

204

new_key.append(ky)

205

new_key.sort()

206

key = ''.join(new_key)

207

return key

208

209

210

def _set_error(self, cr, uid, server_id, context={}):

211

server_obj = self.browse(cr, uid, server_id)

212

if not server_obj.active:

213

return 'not_active'

214

if server_obj.pstate == 'stop' :

215

return 'server_stop'

216

if server_obj.state != 'confirm':

217

return 'server_not_confirm'

218

return True

219

220

def test_verify_email(self, cr, uid, ids, toemail, test=False, code=False):

221

222

serverid = ids[0]

223

self.open_connection(cr, uid, ids, serverid)

224

225

key = False

226

if test and self.server[serverid]['state'] == 'confirm':

227

body = self.server[serverid]['test_email'] or ''

228

else:

229

body = self.server[serverid]['verify_email'] or ''

230

#ignore the code

231

key = self.gen_private_key(cr, uid, ids)

232

#md5(time.strftime('%Y-%m-%d %H:%M:%S') + toemail).hexdigest();

233

234

body = body.replace("__code__", key)

235

236

user = pooler.get_pool(cr.dbname).get('res.users').browse(cr, uid, [uid])[0]

237

body = body.replace("__user__", user.name)

238

239

if len(body.strip()) <= 0:

240

raise osv.except_osv(_('Message Error!'), _('Please configure Email Server Messages [Verification / Test]'))

241

242

try:

243

msg = MIMEText(body.encode('utf8') or '',_subtype='plain',_charset='utf-8')

244

except:

245

msg = MIMEText(body or '',_subtype='plain',_charset='utf-8')

246

247

if not test and not self.server[serverid]['state'] == 'confirm':

248

msg['Subject'] = _('OpenERP SMTP server Email Registration Code!')

249

else:

250

msg['Subject'] = _('OpenERP Test Email!')

251

252

msg['To'] = toemail

253

msg['From'] = tools.ustr(self.server[serverid]['from_email'])

254

255

message = msg.as_string()

256

257

if self.server[serverid]['disclaimers']:

258

body = body + "\n" + self.server[serverid]['disclaimers']

259

260

queue = pooler.get_pool(cr.dbname).get('email.smtpclient.queue')

261

queue.create(cr, uid, {

262

'to':toemail,

263

'server_id':serverid,

264

'name':msg['Subject'],

265

'body':body,

266

'serialized_message':message,

267

'priority':1,

268

'type':'system'

269

})

270

271

if self.server[serverid]['state'] != 'confirm':

272

self.write(cr, uid, ids, {'state':'waiting', 'code':key})

273

274

return True

275

276

def getpassword(self, cr, uid, ids):

277

data = {}

278

cr.execute("select * from email_smtpclient where id = %s" , (str(ids[0]),))

279

data = cr.dictfetchall()

280

return data

281

282

def open_connection(self, cr, uid, ids, serverid=False, permission=True):

283

if serverid:

284

self.server[serverid] = self.getpassword(cr, uid, [serverid])[0]

285

else:

286

raise osv.except_osv(_('Read Error!'), _('Unable to read Server Settings'))

287

288

if permission:

289

if not self.check_permissions(cr, uid, [serverid]):

290

raise osv.except_osv(_('Permission Error!'), _('You have no permission to access SMTP Server : %s ') % (self.server[serverid]['name'],) )

291

292

if self.server[serverid]:

293

try:

294

self.smtpServer[serverid] = smtplib.SMTP()

295

self.smtpServer[serverid].debuglevel = 0

296

self.smtpServer[serverid].connect(str(self.server[serverid]['server']),str(self.server[serverid]['port']))

297

298

if self.server[serverid]['ssl']:

299

self.smtpServer[serverid].ehlo()

300

self.smtpServer[serverid].starttls()

301

self.smtpServer[serverid].ehlo()

302

303

if self.server[serverid]['auth']:

304

password = self.server[serverid]['password']

305

try:

306

password = base64.b64decode(password)

307

except:

308

pass

309

self.smtpServer[serverid].login(str(self.server[serverid]['user']), password)

310

311

except Exception, e:

312

logger.notifyChannel('imap', netsvc.LOG_WARNING, e)

313

314

return True

315

316

def selectAddress(self, cr, uid, partner=None, contact=None, ):

317

email = 'none@none.com'

318

if partner is None and contact is None:

319

return 'none@none.com'

320

321

if partner is not None and contact is None:

322

pool = self.pool.get('res.partner')

323

data = pool.read(cr, uid, [partner])[0]

324

if data:

325

contact = data['address']

326

327

if contact is not None:

328

pool = self.pool.get('res.partner.address')

329

data = pool.read(cr, uid, contact)[0]

330

email = data['email']

331

332

return email

333

334

def select(self, cr, uid, type):

335

pool = self.pool.get('email.smtpclient')

336

ids = pool.search(cr, uid, [('type','=',type)], context=False)

337

if not ids:

338

ids = pool.search(cr, uid, [('type','=','default')], context=False)

339

340

if not ids:

341

return False

342

343

return ids[0]

344

345

# Reports is a list of tuples,where first arguement of tuple is the name of the report,second is the list of ids of the object

346

def send_email(self, cr, uid, server_id, emailto, subject, body='', attachments=[], reports=[], ir_attach=[], charset='utf-8', headers={}, context={}):

347

348

if not emailto:

349

raise osv.except_osv(_('SMTP Data Error !'), _('Email TO Address not Defined !'))

350

351

def createReport(cr, uid, report, ids, name=False):

352

files = []

353

for id in ids:

354

try:

355

service = netsvc.LocalService(report)

356

(result, format) = service.create(cr, uid, [id], {}, {})

357

if not name:

358

report_file = '/tmp/reports'+ str(id) + '.pdf'

359

else:

360

report_file = name

361

362

fp = open(report_file,'wb+')

363

fp.write(result);

364

fp.close();

365

files += [report_file]

366

except Exception,e:

367

continue

368

return files

369

370

smtp_server = self.browse(cr, uid, server_id)

371

if smtp_server.state != 'confirm':

372

raise osv.except_osv(_('SMTP Server Error !'), _('Server is not Verified, Please Verify the Server !'))

373

374

if not subject:

375

subject = "OpenERP Email: [Unknown Subject]"

376

377

try:

378

subject = subject.encode(charset)

379

except:

380

subject = subject.decode()

381

382

#attachment from Reports

383

for rpt in reports:

384

if len(rpt) == 3:

385

rpt_file = createReport(cr, uid, rpt[0], rpt[1], rpt[2])

386

elif len(rpt) == 2:

387

rpt_file = createReport(cr, uid, rpt[0], rpt[1])

388

attachments += rpt_file

389

390

if isinstance(emailto, str) or isinstance(emailto, unicode):

391

emailto = [emailto]

392

393

ir_pool = self.pool.get('ir.attachment')

394

395

for to in emailto:

396

msg = MIMEMultipart()

397

msg['Subject'] = tools.ustr(subject)

398

msg['To'] = to

399

msg['From'] = context.get('email_from', smtp_server.from_email)

400

401

if body == False:

402

body = ''

403

404

if smtp_server.disclaimers:

405

body = body + "\n" + smtp_server.disclaimers

406

407

try:

408

msg.attach(MIMEText(body.encode(charset) or '', _charset=charset, _subtype="html"))

409

except:

410

msg.attach(MIMEText(body or '', _charset=charset, _subtype="html"))

411

412

#add custom headers to email

413

for hk in headers.keys():

414

msg[hk] = headers[hk]

415

416

for hk in smtp_server.header_ids:

417

msg[hk.key] = hk.value

418

419

context_headers = context.get('headers', [])

420

for hk in context_headers:

421

msg[hk] = context_headers[hk]

422

423

# Add OpenERP Server information

424

msg['X-Generated-By'] = 'OpenERP (http://www.openerp.com)'

425

msg['X-OpenERP-Server-Host'] = socket.gethostname()

426

msg['X-OpenERP-Server-Version'] = release.version

427

msg['Message-Id'] = "<%s-openerp-@%s>" % (time.time(), socket.gethostname())

428

429

if smtp_server.cc_to:

430

msg['Cc'] = smtp_server.cc_to

431

432

if smtp_server.bcc_to:

433

msg['Bcc'] = smtp_server.bcc_to

434

435

#attach files from disc

436

for file in attachments:

437

part = MIMEBase('application', "octet-stream")

438

part.set_payload(open(file,"rb").read())

439

Encoders.encode_base64(part)

440

part.add_header('Content-Disposition', 'attachment; filename="%s"' % os.path.basename(file))

441

msg.attach(part)

442

443

#attach files from ir_attachments

444

for ath in ir_pool.browse(cr, uid, ir_attach):

445

part = MIMEBase('application', "octet-stream")

446

datas = base64.decodestring(ath.datas)

447

part.set_payload(datas)

448

Encoders.encode_base64(part)

449

part.add_header('Content-Disposition', 'attachment; filename="%s"' %(ath.name))

450

msg.attach(part)

451

452

message = msg.as_string()

453

data = {

454

'to':to,

455

'server_id':server_id,

456

'cc':smtp_server.cc_to or False,

457

'bcc':smtp_server.bcc_to or False,

458

'name':subject,

459

'body':body,

460

'serialized_message':message,

461

'priority':smtp_server.priority,

462

}

463

self.create_queue_enrty(cr, uid, data, context)

464

465

return True

466

467

def create_queue_enrty(self, cr, uid, data, context={}):

468

queue = pooler.get_pool(cr.dbname).get('email.smtpclient.queue')

469

return queue.create(cr, uid, data, context)

470

471

def _check_history(self, cr, uid, ids=False, context={}):

472

result = True

473

server = self.pool.get('email.smtpclient')

474

queue = self.pool.get('email.smtpclient.queue')

475

sids = self.search(cr, uid, [])

476

for server in self.browse(cr, uid, sids):

477

if server.delete_queue == 'never':

478

continue

479

480

now = datetime.today()

481

days = timedelta(days=server.delete_queue_period)

482

day = now - days

483

kday = day.__str__().split(' ')[0]

484

485

if server.delete_queue == 'content':

486

qids = queue.search(cr, uid, [('server_id','=',server.id), ('date_create','<=',kday)])

487

queue.write(cr, uid, qids, {'serialized_message':False})

488

continue

489

490

if server.delete_queue == 'all':

491

qids = queue.search(cr, uid, [('server_id','=',server.id), ('date_create','<=',kday)])

492

queue.unlink(cr, uid, qids)

493

494

return result

495

496

def _send_emails(self, cr, uid, ids, context={}):

497

queue = self.pool.get('email.smtpclient.queue')

498

history = self.pool.get('email.smtpclient.history')

499

queue.write(cr, uid, ids, {'state':'sending'})

500

501

error = []

502

sent = []

503

remove = []

504

open_server = []

505

506

for email in queue.browse(cr, uid, ids):

507

508

if not email.server_id.id in open_server:

509

open_server.append(email.server_id.id)

510

self.open_connection(cr, uid, ids, email.server_id.id)

511

512

try:

513

self.smtpServer[email.server_id.id].sendmail(email.server_id.email, [email.to, email.cc, email.bcc], tools.ustr(email.serialized_message))

514

message = "message sent successfully to %s from %s server" % (email.to, email.server_id.name)

515

logger.notifyChannel('smtp', netsvc.LOG_INFO, message)

516

except Exception, e:

517

queue.write(cr, uid, [email.id], {'error':e, 'state':'error'})

518

continue

519

520

history.create(cr, uid, {

521

'name':email.body,

522

'user_id':uid,

523

'server_id': email.server_id.id,

524

'email':email.to

525

})

526

if email.server_id.delete_queue == 'after_send':

527

remove.append(email.id)

528

else:

529

sent.append(email.id)

530

531

queue.unlink(cr, uid, remove)

532

queue.write(cr, uid, sent, {'state':'send'})

533

return True

534

535

def _check_queue(self, cr, uid, ids=False):

536

queue = self.pool.get('email.smtpclient.queue')

537

sids = []

538

if not ids:

539

sids = queue.search(cr, uid, [('state','not in',['send','sending']), ('type','=','system')], order="priority", limit=30)

540

ids =[]

541

else:

542

sids = queue.search(cr, uid, [('state','not in',['send','sending']), ('server_id','in',ids)], order="priority", limit=30)

543

544

message = ""

545

if len(sids) > 0:

546

message = "sending %s emails from message queue !" % (len(sids))

547

logger.notifyChannel('smtp', netsvc.LOG_INFO, message)

548

549

result = self. _send_emails(cr, uid, sids, {})

550

return result

551

552

def set_to_draft(self, cr, uid, ids, context={}):

553

self.stop_process(cr, uid, ids, context)

554

self.write(cr, uid, ids, {'state':'new', 'code':False})

555

return True

556

557

def create_process(self, cr, uid, ids, context={}):

558

svr = self.browse(cr, uid, ids[0])

559

if not svr.process_id:

560

res = {

561

'name':'Process : ' + svr.name,

562

'model':'email.smtpclient',

563

'args': repr([ids]),

564

'function':'_check_queue',

565

'priority':5,

566

'interval_number':1,

567

'interval_type':'minutes',

568

'user_id':uid,

569

'numbercall':-1,

570

'doall':False,

571

'active':False

572

}

573

id = self.pool.get('ir.cron').create(cr, uid, res)

574

self.write(cr, uid, ids, {'process_id':id})

575

576

return True

577

578

def start_process(self, cr, uid, ids, context={}):

579

process = self.browse(cr, uid, ids[0], context)

580

if not process.process_id or process.state != 'confirm':

581

raise osv.except_osv(_('SMTP Server Error !'), _('Server is not Verified, Please Verify the Server !'))

582

583

pid = process.process_id.id

584

self.pool.get('ir.cron').write(cr, uid, [pid], {'active':True})

585

self.write(cr, uid, ids, {'pstate':'running'})

586

return True

587

588

def stop_process(self, cr, uid, ids, context={}):

589

pid = self.browse(cr, uid, ids[0], context).process_id.id

590

self.pool.get('ir.cron').write(cr, uid, [pid], {'active':False})

591

self.write(cr, uid, ids, {'pstate':'stop'})

592

return True

593

594

smtpclient()

595

596

class email_headers(osv.osv):

597

_name = 'email.headers'

598

_description = 'Email Headers'

599

_columns = {

600

'server_id':fields.many2one('email.smtpclient', 'SMTP Server'),

601

'key':fields.char('Header', size=64, required=True),

602

'value':fields.char('Value', size=1024, required=False),

603

}

604

email_headers()

605

606

class email_history(osv.osv):

607

_name = 'email.smtpclient.history'

608

_description = 'Email Client History'

609

_order = 'id desc'

610

611

_columns = {

612

'name' : fields.text('Description',required=True, readonly=True),

613

'date_create': fields.datetime('Date',readonly=True),

614

'user_id':fields.many2one('res.users', 'Username', readonly=True, select=True),

615

'server_id' : fields.many2one('email.smtpclient', 'Smtp Server', ondelete='set null', readonly=True, required=True),

616

'model':fields.many2one('ir.model', 'Model', readonly=True, select=True),

617

'resource_id':fields.integer('Resource ID', readonly=True),

618

'email':fields.char('Email',size=64,readonly=True),

619

}

620

621

_defaults = {

622

'date_create': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),

623

'user_id': lambda obj, cr, uid, context: uid,

624

}

625

626

def create(self, cr, uid, vals, context=None):

627

super(email_history,self).create(cr, uid, vals, context)

628

cr.commit()

629

email_history()

630

631

class message_queue(osv.osv):

632

_name = 'email.smtpclient.queue'

633

_description = 'Email Queue'

634

_order = '"to"'

635

_columns = {

636

'to' : fields.char('Mail to', size=1024, readonly=True, states={'draft':[('readonly',False)], 'error':[('readonly',False)]}),

637

'server_id':fields.many2one('email.smtpclient', 'SMTP Server', readonly=True, states={'draft':[('readonly',False)]}),

638

'cc' : fields.char('CC to', size=1024, readonly=True, states={'draft':[('readonly',False)]}),

639

'bcc' : fields.char('BCC to', size=1024, readonly=True, states={'draft':[('readonly',False)]}),

640

'name' : fields.char('Subject', size=1024, readonly=True, states={'draft':[('readonly',False)]}),

641

'body' : fields.text('Email Text', readonly=True, states={'draft':[('readonly',False)]}),

642

'serialized_message':fields.text('Message', readonly=True, states={'draft':[('readonly',False)]}),

643

'state':fields.selection([

644

('draft','Queued'),

645

('sending','Waiting'),

646

('send','Sent'),

647

('error','Error'),

648

],'Message Status', select=True, readonly=True),

649

'type':fields.selection([

650

('default','Default Message'),

651

('system','System Message'),

652

],'Message Type', select=True, readonly=True),

653

'error':fields.text('Last Error', size=256, readonly=True, states={'draft':[('readonly',False)]}),

654

'date_create': fields.datetime('Date', readonly=True),

655

'priority':fields.integer('Message Priority', readonly=True),

656

}

657

_defaults = {

658

'date_create': lambda *a: time.strftime('%Y-%m-%d %H:%M:%S'),

659

'state': lambda *a: 'draft',

660

'priority': lambda *a: '10',

661

'type': lambda *a: 'default',

662

}

663

message_queue()

664

665

class report_smtp_server(osv.osv):

666

_name = "report.smtp.server"

667

_description = "Server Statistics"

668

_auto = False

669

_columns = {

670

'server_id':fields.many2one('email.smtpclient','Server ID',readonly=True),

671

'name': fields.char('Server',size=64,readonly=True),

672

'history':fields.char('History',size=64, readonly=True),

673

'no':fields.integer('Total No.',readonly=True),

674

}

675

def init(self, cr):

676

cr.execute("""

677

create or replace view report_smtp_server as (

678

select min(h.id) as id, c.id as server_id, h.name as history, h.name as name, count(h.name) as no from email_smtpclient c inner join email_smtpclient_history h on c.id=h.server_id group by h.name, c.id

679

)

680

""")

681

682

report_smtp_server()

683

684

# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

685

Older »