admin_administror.py

#!/usr/bin/env python

import os
import pickle
import json
import sys
import admin_login
import lo32

memo_file = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

log = lo32.yankerp(log_file=memo_file + r'\log\Admin.log') # 定义Log
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

admin_json = BASE_DIR + r"\db\admin.json"
user_json = BASE_DIR + r"\db\users.json" 
user_pkl = BASE_DIR + r"\db\users.pkl"

admin_data = {
    "username" : "admin",
    "password" : "admin",
    "type" : "admin"
}


class Admin:
    def __init__(self):
        self.data = {}
        self.data_list = []
        self.save = self.save_admin()
    
    def save_admin(self):
        with open(admin_json, "w", encoding="utf-8") as f:
            f.write(json.dumps(admin_data, indent=4))

    @admin_login.Admin('admin_login')
    def user_auth(self):
        log.info("启动授权认证函数成功...")
        if os.path.exists(user_pkl) and os.path.exists(user_json):
            with open(user_pkl, "rb") as f:
                user_data = pickle.load(f)
                for i in user_data:
                    self.data = i

            self.data['enable'] = 1
            self.data_list.append(self.data)

            with open(user_pkl, "wb") as f:
                pickle.dump(self.data_list, f)
            
            with open(user_json, "w", encoding='utf-8') as f:
                f.write(json.dumps(self.data, indent=4))
                print("授权用户成功".center(60, "-"))
            return True
        else:
            log.error("系统提示：目前没有用户不能做授权相关的操作")
            return False

    def put_user(self):
        log.info('启动查看用户函数成功')
        if os.path.exists(user_pkl) and os.path.exists(user_json):
            print("以下为目前的用户信息".center(60, "-"))
            with open(user_pkl, "rb") as f:
                data = pickle.load(f)
                for i in data:
                    for k, v in i.items():
                        print(f"{k}：{v}")
        else:
            print("目前没有用户信息".center(60, "-"))
            return False

    def menu(self):
        count = True
        while(count):
            admin_menu = {
                "1" : "授权用户",
                "2" : "查看用户",
                "Q" : "退出此程序"
            }

            for k, v in admin_menu.items():
                print(f"{k}:{v}")
            your = input("请您输入相关的选项：").strip().upper()
            if your == "1":
                A = Admin()
                A.user_auth()
            elif your == "2":
                self.put_user()
            elif your == "Q":
                log.info('退出成功，欢迎您再次使用')
                sys.exit()

admin_login.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os
import json
from functools import wraps

memo_file = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
admin_json = memo_file + r"\db\admin.json"


class Admin:
    def __init__(self, funcname):
        self.funcname = funcname
    
    def __call__(self, func):
        @wraps(func)
        def wrapper(*args, **kw):
            if hasattr(self, self.funcname):
                my_func = getattr(self, self.funcname)
                if (my_func(func)):
                    func(*args, **kw)
        return wrapper

    def admin_login(self, func):
        count = True
        while(count):
            admin_user = input("请您输入管理员账号：").strip()
            admin_password = input("请您输入管理员密码：").strip()

            if self.admin_login_pro(admin_user, admin_password):
                return True
            else:
                count = True
    
    def admin_login_pro(self, name, password):
        with open(admin_json, "r") as f:
            data = json.load(f)

        if data['username'] == name and data['password'] == password:
            print("管理员账号密码检测成功".center(60, "-"))
            return True
        else:
            print("管理元账号密码检测失败，请重试".center(60, "-"))
            return False

iamge_result.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import sys
import csv
from PIL import ImageColor 
from PIL import Image
from PIL import ImageEnhance
from PIL import ImageDraw, ImageFont

__Author__ = "YanZanG"


class ImageUtils:
    def __init__(self, image_file):
        self.image = image_file
    
    def create_image(self):
        Count = True
        while(Count):
            try:
                image_width = int(input('请您输入图片的宽：').strip())
                image_high = int(input('请您输入图片的高：').strip())
                im_t_w = int(input('请您输入图片中的内容的宽：').strip())
                im_t_h = int(input('请您输入图片中的内容的高：').strip())
                image_text = input("请您输入内容：").strip()
                image_save_name = input('请您输入保存图片的名称：')
                
                IM_new = Image.new('RGBA', (int(image_width), int(image_high)), 'white')
                pic = ImageDraw.Draw(IM_new)
                pic.text((int(im_t_w), int(im_t_h)), image_text, fill='red')
                IM_new.save(os.path.join(self.image, image_save_name + '.png'))
                IM_new.show()
                Count = False
            except Exception as f:
                print(f)

    def image_logo(self):
        Count = True
        while(Count):
            try:
                if os.path.exists(self.image):
                    Your_logo = input('请您输入logo图片的名称:').strip()
                    Your_image = input('请您输入需要添加logo的图片名称').strip()
                    logo_name = os.path.join(self.image, Your_logo)
                    image_name = os.path.join(self.image, Your_image)
                    if os.path.isfile(logo_name) and os.path.isfile(image_name):
                        logo_image = Image.open(logo_name)
                        logo_i_w, logo_i_h = logo_image.size
                        # 打开目标文件
                        ret_image = Image.open(image_name)
                        ret_i_w, ret_i_h = ret_image.size
                        
                        image_copy = ret_image.copy()
                        image_copy.paste(logo_image, (int(ret_i_w-logo_i_w), int(ret_i_h-logo_i_h)))
                        image_success = input("添加Logo成功，请您输入需要保存的图片名称：").strip()
                        image_copy.save(os.path.join(self.image, image_success + '.jpeg'))
                        image_copy.show()
                        Count = False
                else:
                    print("nonononono")
                    Count = True
            except Exception as e:
                print(e)
    
    def enhance_image(self):
        Count = True
        while(Count):
            if os.path.exists(self.image):
                enhance_image = input("请您输入需要增强图片的名称：").strip()
                enhance_image_result = os.path.join(self.image, enhance_image)
                if os.path.isfile(enhance_image_result):
                    enhance_name = input("请您输入增强后图片的名称").strip()
                    IM = Image.open(enhance_image_result)
                    enh = ImageEnhance.Contrast(IM)
                    IM.save(os.path.join(self.image, enhance_name + '.jpeg'))
                    enh.enhance(1.8).show("增强图片后的效果")
                    Count = False
                else:
                    print("对不起，您输入的文件不存在，请您重新输入！！！")
                    Count = True
            else:
                print(f"您输入的'{self.image}'不存在，请您重新输入！！！")
                Count = True

    def rotate_image(self):
        if os.path.exists(self.image):
            os.chdir(self.image)
            rotate_image = input('请您输入需要翻转的图片名称：').strip()
            image_rota = os.path.join(self.image, rotate_image)
            if os.path.isfile(image_rota):
                IM = Image.open(image_rota)
                Count = True
                while(Count):
                    rotate_data = {
                        "1" : "水平翻转",
                        "2" : "镜像翻转",
                        "3" : "度数翻转",
                        "Q" : "退出翻转"
                    }
                    for k, v in rotate_data.items():
                        print(f"{k}、{v}")
                    Your_x = input("请您输入选项：").strip().upper()

                    if Your_x == "1":
                        IM.transpose(Image.FLIP_LEFT_RIGHT).save("水平翻转.jpg")
                        print(f"图片翻转成功，请在{image_rota}中查看")
                    elif Your_x == "2":
                        IM.transpose(Image.FLIP_TOP_BOTTOM).save("上下翻转.jpg")
                        print(f"图片翻转成功，请在{image_rota}中查看")
                    elif Your_x == "3":
                        image_d = int(input("请您输入需要翻转多少度:").strip())
                        IM.rotate(int(image_d)).save('度数翻转图.jpg')
                        print(f"图片翻转成功，请在{image_rota}中查看")
                    elif Your_x == "Q":
                        Count = False
                    else:
                        print("对不起，您输入的内容有误，请您重新输入！！！")
                        Count = True
            else:
                print("文件输入错误！！！")
        else:
            print("路径检测失败！！！")

    def quit(self):
        sys.exit()

    def iamge_memu(self):
        user_menu = {
            "1" : "创建图像",
            "2" : "添加LOGO",
            "3" : "增强效果图",
            "4" : "翻转图像",
            "Q" : "退出此程序"
        }

        user_menu2 = {
            "1" : "create_image",
            "2" : "image_logo",
            "3" : "enhance_image",
            "4" : "rotate_image",
            "Q" : "quit"
        }
        Count = True
        while(Count):
            for k, v in user_menu.items():
                print(f"{k}、{v}")
            User_choice = input("请您输入选项：").strip().upper()
            if User_choice == "":
                print("选项不能为None，请您重新输入！！！")
                Count = True
            else:
                if hasattr(self, user_menu2.get(User_choice)):
                    func = getattr(self, user_menu2.get(User_choice))
                    func()
                else:
                    print("系统检测错误，请您输入正确的选项")


def main():
    Count = True
    while(Count):
        file_image = input("请您输入图片所在的路径：").strip()
        if os.path.exists(file_image):
            IM = ImageUtils(file_image)
            IM.iamge_memu()
        else:
            print("路径检测错误，请您重新输入路径！！！")
            Count = True

if __name__ == "__main__":
    main()

lo32.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import logging

def yankerp(logger_name="YANKAI-LOG", log_file="yankai.log", level=logging.DEBUG):
    # 创建logger对象
    logger = logging.getLogger(logger_name)
    logger.setLevel(level)

    # 创建控制台
    ch = logging.StreamHandler()
    ch.setLevel(level)

    # 创建文件
    fh = logging.FileHandler(filename=log_file, encoding="utf-8")

    # create formatter
    formatter = logging.Formatter('%(asctime)s - %(filename)s - %(name)s - [line:%(lineno)d]- %(levelname)s - %(message)s')

    # 添加 formatter

    ch.setFormatter(formatter)
    fh.setFormatter(formatter)

    logger.addHandler(ch)
    logger.addHandler(fh)

    return logger

main.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import sys
import os
import MemoAdmin
import admin_administror
import lo32

memo_file = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

log = lo32.yankerp(log_file=memo_file + r'\log\memo_main.log') # 定义Log


def main_menu():
    log.info("开始启动main_menu函数")
    count = True
    while(count):
        print("请您选择您的身份".center(60, "-"))
        menu = {
            "1" : "普通用户登陆",
            "2" : "管理员用户登陆",
            "Q" : "退出此程序"
        }
        for k, v in menu.items():
            print(f"{k}：{v}")
        your = input("请您输入相关选项：").strip().upper()
        if your == "1":
            A = MemoAdmin.Memo_Admin()
            A.user_input()
        elif your == "2":
            B = admin_administror.Admin()
            B.menu()
        elif your == "Q":
            log.info("退出main_menu函数成功")
            sys.exit("退出成功")            
        else:
            log.error("对不起，您输入的选项有误，请您重新输入!")
            count = True


def main():
    main_menu()

if __name__ == "__main__":
    main()

memo_email.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import smtplib
from smtplib import SMTP_SSL 
from email.header import Header 
from email.mime.text import MIMEText


class Email(object):
    def __init__(self, email_from, email_to, password, email_title, email_text):
        self.password = password
        self.email_from = email_from
        self.email_to = email_to
        self.email_text = email_text
        self.email_title = email_title

    def get_password(self):  #  获取邮箱授权码
        return self.password

    def send_email(self):
        try:
            smtp = SMTP_SSL("smtp.qq.com", "465")  #  邮件服务器地址
            smtp.login(self.email_from, self.get_password())  #  邮件账户密码

            msg = MIMEText(self.email_text, "plain", "utf-8")
            msg["Subject"] = Header(self.email_title, "utf-8")  #  邮件的标题.
        
            smtp.sendmail(self.email_from, self.email_to, msg.as_string())
            smtp.quit()
        except smtplib.SMTPException as e:
            print(e)


def main():
    Count = True
    while(Count):
        Your_from = input("请您输入发件邮箱：")
        Your_to = input("请您输入收件人邮箱...")
        Your_password = input("请您输入发件邮箱密码：")
        Your_title = input("请您输入邮件标题：")
        Your_text = input("请您输入邮件内容：")
        if Your_from == "" and Your_to == "":
            print("发件人邮箱地址或收件人邮箱地址不能为空。。。")
            Count = True
        elif Your_password == "" and Your_title == "":
            print("邮箱密码,邮件内容不能为空！！！")
            Count = True
        elif Your_text == "":
            print("发件内容不能为空！！！")
            Count = True
        else:
            try:
                A = Email(Your_from, Your_to, Your_password, Your_title, Your_text)
                A.send_email()
                Count = False
            except Exception as e:
                print("发送邮件失败,请您重试....".center(50, "-"))
                print(e)
                Count = False

MemoAdmin.py

#!/usr/bin/env python
# -*- coding:utf-8 -*-

import time
import json
import pickle
import lo32
import os
import sys
import memo_email
import utilts

memo_file = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

log = lo32.yankerp(log_file=memo_file + r'\log\memo.log') # 定义Log
data_pkl = memo_file + r'\db\memo.pkl' #  定义data_pkl 文件的路径
data_text = memo_file + r'\db\memo.txt'  #  定义data_text文件的路径
data_json = memo_file + r'\db\memo.json'  #  定义json文件的路径

__Author__ = "YanZanG"  #  创造者

memo_list = []
memo_json_data = {}


class Memo_Admin:
    """
    备忘录程序类
    """
    log.info("启动备忘录程序成功....")

    def __init__(self):
        self.memo_data_dict = {}

    @utilts.Chatends('log')
    def add_memo(self):
        """
        添加备忘录
        """
        if os.path.exists(data_pkl):
            with open(data_pkl, "rb") as f:
                data = pickle.load(f)
                for i in data:
                    memo_list.append(i)
        Count = True
        while(Count):
            Memo_Title = input("请您输入备忘录标题：").strip()
            Memo_Event = input("请您输入备忘录事件：").strip()
            
            if Memo_Title == "" or Memo_Event == "":
                log.error("标题或事件不能为空，请您重新输入！")
                Count = True
            else:
                Memo_ID = self.memo_id()
                Memo_date = self.date_memo()

                self.memo_data_dict["Memo_ID"] = Memo_ID
                self.memo_data_dict["Memo_Title"] = Memo_Title
                self.memo_data_dict["Memo_Event"] = Memo_Event
                self.memo_data_dict["Memo_date"] = Memo_date

                memo_list.append(self.memo_data_dict)
                log.info(f"添加备忘录信息成功，目前一共有{len(memo_list)}条数据.....")
                self.memo_data_dict = {}
                Count = False

                print("添加数据成功，您是否继续添加？(yes/no)")

                N = input("请您输入：").strip()
                if N == "yes" or N == "y":
                    Count = True
                else:
                    self.save_data_memo()
                    self.save_text_memo()
                    self.save_json_memo()
                    Count = False

    def memo_json_API(self, Count):
        "Json数据接口"
        ret = {'status': 0, 'statusText': 'ok', 'data': {}} # TODO
        with open(data_json) as f:
            data = json.load(f)
        try:
            ret["data"] = data[Count]
        except Exception as f:
            ret["status"] = "1"
            ret["statusText"] = f
        return ret

    def inquire_memo(self):
        """
        查找备忘录
        """
        if os.path.exists(data_pkl):
            Count = True
            while(Count):
                menu = {
                    "1" : "备忘录ID查找",
                    "2" : "备忘录月份查找",
                    "Q" : "退出查找备忘录"
                }
                for k, v in menu.items():
                    print(f"{k}、{v}")

                Your_chose = input("请您选择：").strip().upper()
                if Your_chose == "1":
                    ID = int(input("请您输入备忘录ID号:"))

                    with open(data_pkl, "rb") as f:
                        data = pickle.load(f)
                        try:
                            for k, v in data[ID].items():
                                print(f"{k}:{v}")
                        except Exception as f:
                            print(f)
                elif Your_chose == "2":
                    Your_num = int(input("请您输入您需要查询的月份："))
                    if Your_num <= 9:
                        data = self.memo_json_API("0" + str(Your_num))
                    print(data['data'])
                elif Your_chose == "Q":
                    Count = False
        else:
            print("您目前没有数据，是否需要添加数据？(yes/no)")
            Your_chose2 = input("请您选择：").strip()
            if Your_chose2 == "yes":
                self.add_memo()
            elif Your_chose2 == "no":
                sys.exit("欢迎您再次使用，再见".center(50, "-"))

    def delete_memo(self):
        """
        删除备忘录
        """
        Count = True
        if os.path.exists(data_pkl):
            with open(data_pkl, "rb") as f:
                data = pickle.load(f)
                for i in data:
                    memo_list.append(i)
                    for k, v in i.items():
                        print(f"{k}-{v}")
                Your_del = int(input("请您输入需要删除的ID：").strip())
                memo_list.pop(Your_del)
                self.save_data_memo()
                self.save_text_memo()
                self.save_json_memo()
        else:
            print("您目前没有数据是否现需要添加数据？(yes/no)")
            Your_chose3 = input("请您输入选项：")
            if Your_chose3 == "yes":
                self.add_memo()
            else:
                log.info("欢迎您再次使用，再见~")

    def serach_memo(self):
        "查找历史备忘录"
        if os.path.exists(data_pkl):
            with open(data_pkl, "rb") as f:
                data = pickle.load(f)
                for i in data:
                    for k, v in i.items():
                        print(f"{k}:{v}")
        else:
            log.info("请添加数据后重试！！！")

    def memo_id(self):
        """
        获取memo_id
        """
        return len(memo_list)

    def save_data_memo(self):
        """
        保存备忘录为PKL
        """
        with open(data_pkl, 'wb') as f:
            pickle.dump(memo_list, f)
        log.info("备忘录数据将成功添加到PKL文件中....")

    def save_text_memo(self):
        """
        保存备忘录数据为txt
        """
        if os.path.exists(data_text):
            os.remove(data_text)
        for i in memo_list:
            for k, v in i.items():
                with open(data_text, "a") as f:
                    f.write(f"{k}:{v}" + "\n")
        log.info("备忘录数据将成功的添加到txt文本文件中....")

    def save_json_memo(self):
        """
        保存备忘录数据为json
        """
        C = str(time.strftime("%m", time.localtime()))
        memo_json_data[C] = memo_list

        with open(data_json, 'w') as f:
            json.dump(memo_json_data, f, indent=4)
        log.info("备忘录数据将成功的添加到json文件中....")

    def email(self):
        "调用email"
        memo_email.main()

    def date_memo(self):
        """
        输出当前备忘录记录时间
        """
        return time.strftime("%Y-%m-%d %X", time.localtime())

    @utilts.Chatends('log')
    def exit_memo(self):
        "退出备忘录"
        log.info("退出备忘录成功！！！")
        sys.exit()

    @utilts.Chatends('user_registered')
    @utilts.Chatends('user_login')
    @utilts.Chatends('log')
    def user_input(self):
        user_menu = {
            "1" : "添加备忘录",
            "2" : "删除备忘录",
            "3" : "查找备忘录",
            "4" : "查看历史备忘录信息",
            "5" : "发送邮件",
            "Q" : "退出备忘录"
        }

        user_menu2 = {
            "1" : "add_memo",
            "2" : "delete_memo",
            "3" : "inquire_memo",
            "4" : "serach_memo",
            "5" : "email",
            "Q" : "exit_memo"
        }

        Count = True
        while(Count):
            for k, v in user_menu.items():
                print(f"{k}、{v}")
            User_choice = input("请您输入选项：").strip().upper()
            if User_choice == "":
                log.error("选项不能为None，请您重新输入！！！")
                Count = True
            else:
                if hasattr(self, user_menu2.get(User_choice)):
                    func = getattr(self, user_menu2.get(User_choice))
                    func()
                else:
                    log.error("系统检测错误，请您输入正确的选项")
            
if __name__ == "__main__":
    memo = Memo_Admin()
    memo.user_input()

utilts.py

#!/usr/bin/env python

import re
import json
import pickle
import os
import logging
from functools import wraps

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

admin_json = BASE_DIR + r"\db\admin.json"
user_json = BASE_DIR + r"\db\users.json"
user_pkl = BASE_DIR + r"\db\users.pkl"
function_log = BASE_DIR + r"\log\function.log"


class Chatends:
    def __init__(self, funcname, filename=function_log):
        self.funcname = funcname
        self.filename = filename
        self.user_data = {}
        self.user_list = []
    
    def __call__(self, func):
        @wraps(func)
        def wrapper(*args, **kw):
            if hasattr(self, self.funcname):
                my_func = getattr(self, self.funcname)
                if (my_func(func)):
                    func(*args, **kw)
        return wrapper
    
    def log(self, func):
        str_log = "函数{}开始运行了....".format(func.__name__)
        with open(self.filename, 'a', encoding='utf8') as f:
            print(str_log)
            f.write(str_log + '\n')
        return True
    
    def user_verification(self, name, password):
        user_name = re.compile(r"^[a-zA-Z]\w{3,8}")
        user_password = re.compile(r"^[a-zA-Z]\w{3,16}")
        
        if user_name.match(name) and user_password.match(password):
            return True
        else:
            return False
    
    def user_login_ver(self):
        if os.path.exists(user_json) and os.path.exists(user_pkl):
            with open(user_pkl, "rb") as f:
                data = pickle.load(f)
                for i in data:
                    name = i
            return name
        else:
            return False

    def add_users(self, name, password):
        self.user_data["username"] = name
        self.user_data["password"] = password
        self.user_data["type"] = "user"
        self.user_data["enable"] = 0
        self.user_list.append(self.user_data)

        if len(self.user_list) > 0:
            return True
        else:
            return False

    def save_users_json(self, name, password):
        with open(user_json, "w", encoding="utf-8") as f:
            f.write(json.dumps(self.user_data, indent=4))
    
    def save_users_pkl(self, name, password):
        with open(user_pkl, "wb") as f:
            pickle.dump(self.user_list, f)

    def user_login(self, func):
        print("欢迎来到登陆页面".center(60, "-"))
        count = True
        while(count):
            your_name = input("请您输入您的用户名：").strip()
            your_password = input("请您输入您的密码：").strip()

            if self.user_verification(your_name, your_password):
                result_name = self.user_login_ver()
                if result_name["username"] == your_name and result_name["password"] == your_password:
                    print("登陆成功....")
                    if result_name['enable'] == 1:
                        print("管理员授权成功，正在跳转至功能页面")
                        return True
                    else:
                        print(f"对不起，用户{result_name['username']}暂无授权，请联系管理员进行授权".center(60, "-"))
                        return False
                else:
                    print("对不起，您输入的内容有误，您是否需要输出账号密码信息？(yes/no)")
                    Your_chose = input("请您选择：").strip()
                    if Your_chose == "yes":
                        with open(user_pkl, "rb") as f:
                            data = pickle.load(f)
                            for i in data:
                                for k, v in i.items():
                                    print(f"{k}：{v}")
                    else:
                        return False
            else:
                print("对不起，您输入的用户名密码有误，请您重新输入".center(60, "-"))
                count = True

    def user_registered(self, func):
        print("欢迎来到注册页面".center(60, "-"))
        prompt = """
        1、用户名必须以英文3-8位
        2、密码均不接受特殊字符，符号,可用英文+数字 3-16位
        """
        if os.path.exists(user_json) and os.path.exists(user_pkl):
            print("已检测到用户，正在跳转至登陆页面".center(60, "-"))
            return True
        else:
            print(prompt)
            Count = True
            while(Count):
                Your_reg_name = input("请您设置您的用户名：").strip()
                Your_reg_password = input("请您设置您的密码：").strip()

                if self.user_verification(Your_reg_name, Your_reg_password):
                    print("用户名密码合法...")
                    if self.add_users(Your_reg_name, Your_reg_password):
                        self.save_users_json(Your_reg_name, Your_reg_password)
                        self.save_users_pkl(Your_reg_name, Your_reg_password)
                        print("注册成功，正在跳转至登陆页面".center(60, "-"))
                        return True
                    else:
                        False
                else:
                   print("对不起，您的用户名密码输入不合法，请您重新输入".center(60, "-"))
                   Count = True