import os
import re
import shutil
import subprocess
import time



englishtown_url = "http://10.128.42.155:8080/view/Engage/job/engage-android-release/{0}/artifact/engage/build/outputs/apk/engage-englishtown-live-release.apk"
corporate_url = "http://10.128.42.155:8080/view/Engage/job/engage-android-release/{0}/artifact/engage/build/outputs/apk/engage-corporate-live-release.apk"

current_dir = os.path.split(os.path.realpath(__file__))[0]
report_path = current_dir + "/apk/"
old_path = current_dir + "/old/"
new_path = current_dir + "/new/"


def exec_command(cmd):
    result = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
    (stdoutdata, stderrdata) = result.communicate()
    if (re.search("error", str(stdoutdata))):
        print "error occur!"
    else:
        return stdoutdata

def check_folder(name):
    if os.path.exists(name):
        # os.removedirs(report_path)
        shutil.rmtree(name)

    else:
        pass
    os.makedirs(name)


def get_url(url,folder_name):
    cmd = 'curl -O {0}'.format(url)
    os.chdir(folder_name)
    exec_command(cmd)
    os.chdir(current_dir)


def check_md5(file):
    cmd = 'md5 {0}'.format(file)
    md5_id = exec_command(cmd)
    print "{0} md5 value is {1}".format(file, md5_id)


def find_devices():
    rst = os.popen('adb devices').read()
    devices = re.findall(r'(.*?)\s+device',rst)
    if len(devices) > 1:
        Ids = devices[1:]
    else:
        Ids = []
    return Ids

def find_apks():
    apks = []
    for c in os.listdir(os.getcwd()):
        if os.path.isfile(c) and c.endswith('.apk'):
            apks.append(c)
    return apks

def upgrade_englishtown(old_folder,new_folder):
    old_version = raw_input("please input the old build number")
    new_version = raw_input("please input the new build number")
    old_apk_name = englishtown_url.format(old_version).split("/")[-1]
    get_url(englishtown_url.format(old_version),old_folder)
    new_apk_name = englishtown_url.format(new_version).split("/")[-1]
    get_url(englishtown_url.format(new_version),new_folder)
    return old_apk_name, new_apk_name

def upgrade_corporate(old_folder,new_folder):
    old_version = raw_input("please input the old build number")
    new_version = raw_input("please input the new build number")
    old_apk_name = corporate_url.format(old_version).split("/")[-1]
    get_url(corporate_url.format(old_version),old_folder)
    new_apk_name = corporate_url.format(new_version).split("/")[-1]
    get_url(corporate_url.format(new_version),new_folder)
    return old_apk_name, new_apk_name

def install_apks(apk_name):
    cmd = 'adb install {0}'.format(apk_name)
    print cmd
    result = exec_command(cmd)
    print result
    if (re.search("success", result)):
        print "install success!"
    else:
        print "install fail!"



def main():

    choose = raw_input("please select the type you want: 1:md5,2:upgrade_englishtown,3:upgrade_corporate")
    if choose == '1':
        build_id = raw_input("please input the build number")
        check_folder(report_path)
        get_url(englishtown_url.format(build_id),report_path)
        get_url(corporate_url.format(build_id),report_path)
        if os.path.exists(report_path):
            for file in os.listdir(report_path):
                check_md5(report_path  + file)
        else:
            "please check your network!"
    elif choose == '2':
        check_folder(old_path)
        check_folder(new_path)
        (old_apk,new_apk) =upgrade_englishtown(old_path,new_path)
        print "old apk is : %s" % old_apk
        install_apks(old_path + old_apk)
        print "new apk is : %s" % new_apk
        install_apks(new_path+new_apk)


    elif choose == '3':
        check_folder(old_path)
        check_folder(new_path)
        (old_apk, new_apk) = upgrade_corporate(old_path,new_path)
        print "old apk is : %s" % old_apk
        install_apks(old_path + old_apk)
        print "new apk is : %s" % new_apk
        install_apks(new_path+new_apk)

    else:
        print "please select again"




if __name__ == '__main__':
    main()

import os
import re
import subprocess
import time

current_time = time.strftime('%Y-%m-%d-%H-%M-%S', time.localtime(time.time()))


class iosinformation():
    def exec_command(self, cmd):
        result = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
        (stdoutdata, stderrdata) = result.communicate()
        # print("Result is:%s") % stdoutdata
        if (re.search("No device found", str(stdoutdata)) or re.search("Could not connect", str(stdoutdata))):
            print "Please connet it agian, or add permission like: brew install libimobiledevice --HEAD,sudo chmod -R 777 /var/db/lockdown/"
        else:
            return stdoutdata

    def Get_UUID(self):
        cmd = 'idevice_id -l'
        uuid = self.exec_command(cmd)
        return uuid

    def Get_Device_Name(self):
        cmd = 'ideviceinfo -k DeviceName'
        device_name = self.exec_command(cmd)
        return device_name

    def Get_Device_information(self):
        cmd = 'ideviceinfo -k ProductVersion'
        device_information = self.exec_command(cmd)
        return device_information

    def Get_Device_Product_type(self):
        cmd = 'ideviceinfo -k ProductType'
        product_type = self.exec_command(cmd)
        return product_type

    def List_All_Pakages(self, uuid):
        cmd = 'ideviceinstaller -u {0}'.format(uuid)

        print cmd
        all_pakages = self.exec_command(cmd)

        return all_pakages

    def List_All_Logs(self, uuid):
        all_logs = "idevicesyslog -u {0}".format(uuid)
        return all_logs

    def Take_Screenshot(self):
        current_dir = os.path.split(os.path.realpath(__file__))[0]
        cmd1 = "idevicescreenshot {0} + '/' + screenshot-DATE.tiff".format(current_dir)
        cmd2 = "sips - s format png {0}.tiff - -out {1}.png".format(current_time, current_time)
        self.exec_command(cmd1)
        print "ok"
        # self.exec_command(cmd2)

    def Install_Ipa(self, ipa):
        cmd = 'ideviceinstaller -i {0}'.format(ipa)
        result = self.exec_command(cmd)
        return result

    def Uninstall_Ipa(self, appid):
        cmd1 = 'ideviceinstaller -l'
        cmd2 = 'ideviceinstaller -U {0}'.format(appid)
        result = self.exec_command(cmd1)
        appids=[]
        for id in result.split('\n'):
            if re.search('-',id):
                str = id[0:id.find("-")].strip()
                appids.append(str)

            else:
                pass
        print appids
        if appid in appids:
            result = self.exec_command(cmd2)
        else:
            print "The appid dosen't exit in the devices"



        # cmd2 = 'ideviceinstaller -u appid'.format(appid)
        # result = self.exec_command(cmd)
        # return result


def main():
    ios = iosinformation()

    uuid = ios.Get_UUID()
    print " uuid is {0}".format(uuid)
    device = ios.Get_Device_Name()
    print " device is {0}".format(device)
    device_info = ios.Get_Device_information()
    print " device_info is {0}".format(device_info)
    product_type = ios.Get_Device_Product_type()
    print " product_type is {0}".format(product_type)
    # all_pakagas = ios.List_All_Pakages(uuid)
    # print " all_pakagas is {0}".format(all_pakagas)
    ios.Take_Screenshot()
    ios.Install_Ipa('/Users/anderson/testcode/python/flask/uploads/englishtown_corporate_daily-190-2016.07.15.ipa')
    #ios.Uninstall_Ipa("com.ef.engage.englishtown.uat.dailydebug")



if __name__ == '__main__':
    main()

from flask import Flask
from OpenSSL import SSL

import os

context = SSL.Context(SSL.SSLv23_METHOD)
cer = os.path.join(os.path.dirname(__file__), 'resources/anderson.crt')
key = os.path.join(os.path.dirname(__file__), 'resources/anderson.key')

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello World!'

if __name__ == '__main__':
    context = (cer, key)
    app.run( host='0.0.0.0', port=5000, debug = True, ssl_context=context)

├── __init__.py
├── application
│   ├── __init__.py
│   ├── app.py
│   ├── models.py
│   └── templates
│       ├── index.html
│       ├── layout.html
│       └── show.html
├── manage.py

# encoding=utf-8

from flask_script import Manager
from application.app import app
manager = Manager(app)
app.config['DEBUG'] = True
if __name__ == '__main__':
    manager.run()

#encoding=utf-8
from flask import Flask
from flask import render_template
from flask import url_for
from flask import redirect
from flask import request,flash
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
track_modifications = app.config.setdefault('SQLALCHEMY_TRACK_MODIFICATIONS', True)
app.config['SQLALCHEMY_DATABASE_URI']="mysql://root:@localhost:3306/message"
db = SQLAlchemy(app)
SECERT_KEY="a secret key"
app.config.from_object(__name__)
app.secret_key=app.config['SECERT_KEY']
from models import Message

@app.route('/',methods=['POST','GET'])
def index():
        if request.method == 'POST':
                name = request.form['name']
                email = request.form['email']
                content = request.form['content']
                title = request.form['title']
                mess = Message(name=name,email=email,content=content,title=title)
                db.session.add(mess)
                db.session.commit()
                flash("Add Message Sucess!!")
                #return name+email+content+title
                return redirect(url_for("index"))
        else:
                mess = Message.query.all()
                return render_template("index.html",message=mess)

@app.route('/show/<int:id>')
def show(id):
        mess = Message.query.filter_by(id=id).first()
        if mess !=None:
                return render_template("show.html",message=mess)
        else:
                return redirect(url_for("index"))

#encoding=utf-8
from app import db
from datetime import datetime

class Message(db.Model):
        __tablename__ ="message"
        id = db.Column(db.Integer,primary_key=True)
        name = db.Column(db.String(200))
        time = db.Column(db.DateTime,default=datetime.now())
        content = db.Column(db.String(255))
        email = db.Column(db.String(100))
        title = db.Column(db.String(255))

        def __init__(self,name,content,email,title):
                self.name = name
                self.content = content
                self.email = email
                self.title = title

        def __repr__(self):
                return "<User:%s>" %self.name


if __name__=="__main__":
        db.create_all()

def get_words_dict(target):      
table = {}      
line, number = re.subn(r"\W", " ", target)  
for word in line.split():  
     if table.has_key(word):                    
       table[word] += 1    
     else:        
       table[word] = 1  
   return table

#!/usr/bin/python
# coding=utf-8
import subprocess
import sys
import urllib2
import time
import json
import re
import numpy
import matplotlib.pyplot as plt
from collections import Counter

__author__ = 'anderson'

reload(sys)
sys.setdefaultencoding('utf-8')

log_file = r'gitfiles.log'
start_time_stamp = time.strftime("%Y%m%d%H%M%S")

def write_log(file_name, content):
    file_object = open(file_name, 'a+')
    file_object.write(content)
    file_object.close()


def get_comments(obj):
    sentence = obj[obj.index(" "):].strip().rstrip("\n")
    return sentence


def get_file(obj):
    if obj.rfind("..."):
        file = obj[obj.rindex("...") + 4:].strip().rstrip("\n")
    return file


def get_git_info():
    commit_comments = []
    file_comments = []
    commit_pattern = re.compile(r'^\d+\w+', re.IGNORECASE)
    file_pattern = re.compile(r'^:\d+\w+', re.IGNORECASE)
    cmd = "git whatchanged --since='2 weeks ago' --pretty=oneline"
    lines = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout.readlines()
    for line in lines:
        if re.search(commit_pattern, line):
            commit = get_comments(line)
            commit_comments.append(commit)
            write_log(log_file, commit)
            write_log(log_file, "\n")
        elif re.search(file_pattern, line):
            commit_file = get_file(line)
            file_comments.append(commit_file)
            write_log(log_file, commit_file)
            write_log(log_file, "\n")
    return commit_comments, file_comments


def get_file_statistic(target):
    table = Counter(target)
    return table


def get_words_dict(target):
    table = {}
    line, number = re.subn(r"\W", " ", target)
    for word in line.split():
        if table.has_key(word):
            table[word] += 1
        else:
            table[word] = 1
    return table


def get_words_graphic(wordlist):
    keylist = wordlist.keys()
    vallist = wordlist.values()
    barwidth = 0.3
    xVal = numpy.arange(len(keylist))
    plt.xticks(xVal + barwidth / 2.0, keylist, rotation=90)
    plt.bar(xVal, vallist, width=barwidth, color='y')
    plt.title(u'词频分析图')
    plt.show()


def get_file_graphic(wordlist):
    keylist = wordlist.keys()
    vallist = wordlist.values()
    barwidth = 0.3
    xVal = numpy.arange(len(keylist))
    plt.yticks(xVal + barwidth / 2.0, keylist, rotation=0)
    plt.barh(xVal, vallist, height=barwidth, color='b')
    plt.title(u'文件分析图')
    plt.show()


def remove_dict(obj, key):
    if key in obj.keys():
        obj.pop(key)


if __name__ == '__main__':

    write_log(log_file, start_time_stamp)
    write_log(log_file, "\n")

    comments, files = get_git_info()

    remove_words = ['the', 'a', 'bug', 'to', 'of', 'so', 'one', 'more', 'we', 'ME', 'Update', 'app', 'our', 'issue',
                   'want', 't', 'work']

    commit_str = ''.join(comments)
    words_number = get_words_dict(commit_str)

    for word in remove_words:
        remove_dict(words_number, word)

    fine_number = get_file_statistic(files)
    get_words_graphic(words_number)
    get_file_graphic(fine_number)

from pylab import *

# make a square figure and axes
figure(1, figsize=(6,6))
ax = axes([0.1, 0.1, 0.8, 0.8])

fracs = [45, 30, 25]             #每一块占得比例，总和为100
explode=(0, 0, 0.08)             #离开整体的距离，看效果
labels = 'Hogs', 'Dogs', 'Logs'  #对应每一块的标志

pie(fracs, explode=explode, labels=labels,
                autopct='%1.1f%%', shadow=True, startangle=90, colors = ("g", "r", "y"))
                                 # startangle是开始的角度，默认为0，从这里开始按逆时针方向依次展开

title('Raining Hogs and Dogs')   #标题

show()

import matplotlib.pyplot as plt 

plt.xlabel(u'性别')
plt.ylabel(u'人数')
plt.bar(left = (0,1),height = (1,0.5),width = 0.35)
plt.show()

import matplotlib.pyplot as plt 

plt.xlabel(u'性别')
plt.ylabel(u'人数')


plt.title(u"性别比例分析")
plt.xticks((0,1),(u'男',u'女'))
rect = plt.bar(left = (0,1),height = (1,0.5),width = 0.35,align="center")

plt.legend((rect,),(u"图例",))

plt.show()